|Home >> All >> gnu >> java >> [ beans Javadoc ]|
|||gnu.java.beans.decoder.* (37)||||gnu.java.beans.editors.* (10)|
|||gnu.java.beans.encoder.* (30)||||gnu.java.beans.encoder.elements.* (15)|
gnu.java.beans: Javadoc index of package gnu.java.beans.
ScanEngine: The ScanEngine is the main class of the backend of the XML persistence algorithm. It scans java.beans.Expression and java.beans.Statement instances and some raw objects via the writeObject(java.lang.Object) 55 method and feeds it to a state machine. The state machine then constructs and object tree which is finally written as XML by a Writer implementation. How does it work? The ScanEngine sits below the java.beans.XMLEncoder class and is called by it exclusively. The XMLEncoder sends interpretive data by invoking writeExpression(java.beans.Expression) 55 , writeStatement(java.beans.Statement) ...
Writer: A Writer represents a simplified interface to an XML writer that is used for the XML persistence mechanism. Its sole purpose is to allow multiple backends which may remove the need to have certain APIs in the classpath. Eg. it is possible to write a stripped down XML Writer that does not rely on SAX, StAX or DOM APIs. The caller may assume that every action is done immediately. However it is possible that the underlying implementation uses buffering streams. To make sure the data is written call the flush method. The Writer implementation should care about the formatting of the XML stream making ...
IgnoringScannerState: A special ScannerState implementation that ignores all child elements. Consider the call hierarchy: methodInvocation objectInstantiation classResolution* objectInstantiation classResolution When the ignoring state is active one can filter the elements of one level. One has to set up the state machine that a transition via "class resolution" from a state that was reached via "object instantation" reaches an IgnoringScannerState . Setting the default successor of a IgnoringScannerState to itself causes all elements of the call hierarchy to be skipped until another state is reached by going back.
ObjectId: ObjectId provides an object identification mechanism which gives each object a name in the form <class><Nameindex> . Each id can be in an unused state which means that only one instance of the object is in use and a special id is not needed. Certain gnu.java.beans.encoder.elements.Element subclasses use this feature to find out whether they write the "id" attribute or not. An ObjectId instance is typically given to multiple objects. The second user should then invoke the init() 55 method to generate the identification string and bring the id in the 'used' state.
ClassPersistenceDelegate: The ClassPersistenceDelegate creates Expression instances which denote class resolutions. The class resolution is always the last step when serializing a tree of objects. Due to the recursive nature of the algorithm we need a way to end the recursion. This is achieved by the implementation of this instantiate method. Arbitrary classes are described with a call to Class.forName . However for the Class class we call getClass() on a String.class instance. This in turn lead to the resolution of the String class which is always encoded as "".getClass() . Finally the Encoder treats strings in a special ...
GenericScannerState: This class is a ScannerState implementation that creates suitable gnu.java.beans.encoder.elements.Element instances for each transition variant. Furthermore it can optionally skip a certain number of child elements. The algorithm can cope with the fact that one GenericScannerState instance may be called at different levels of recursions.
DefaultExceptionListener: The DefaultExceptionListener is the default implementation of the java.beans.ExceptionListener interface. An instance of this class is used whenever the user provided no ExceptionListener instance on its own. The implementation just writes the exception's message to System.err and is used by the java.beans.Encoder and the java.beans.XMLDecoder .
Context: A Contect object describes the current state and the call number while processing the original object tree in the ScanEngine . The class allows to distinguish the different calling states and is neccessary for the child element skipping feature of the GenericScannerState .
Root: Root provides a simple interface to a tree of objects. Using an instance of this class a logical representation of the real object tree that is serialized can be built. When the actual data should be written as XML Root and gnu.java.beans.encoder.elements.Element class can provide context information which is used to write the best fitting XML representation.
Context: A Context is the environment for an object which is being assembler. If there are no errors each handler creates one Context. Depending on the result of isStatement() a Context can be statement or an expression. An expression returns a value to the Context of its parent handler, a statement does not. Whenever a Context is a statement the parent handler's Context is informed about that through the notifyStatement -method.
ObjectContext: ObjectContext is a Context implementation that wraps a simple Object instance. The instance can be provided when the Context is created (due to an 'idref' attribute) or later (eg. <int> tag) The ObjectContext does not accept any parameter object and ignores notifications about sub-contexts being statements.
AssemblyException: The AssemblyException is used to wrap the cause of problems when assembling objects. In all cases only the wrapped exception is given to the PersistenceParser's ExceptionListener instance (never the AssemblyException itself). Note: Often multiple steps are needed to construct a fully usuable object instance. Such a construction can be called assembly and thats why this exception was named AssemblyException.
ConstructorContext: A ConstructorContext is a Context implementation which collects the parameters for a constructor call and instantiates the result object using that constructor. After that sub-contexts can invoke methods on the result object. The constructor is invoked when a sub-context is a statement or the Context ends.
PropertyContext: PropertyContext is a Context implementation that is very similar to MethodContext and IndexContext. The sole purpose of PropertyContext to find out whether it should 'set' or 'get' a certain property. This decision is made using the number of arguments. When the method call has to be made and there is no argument we 'get' the property. With one argument it is 'set'.
DummyAppletContext: A placeholder AppletContext implementation that does nothing. This is the default implementation for GNU Classpath and is used for Applet beans being created with java.beans.Beans.instantiate . It has no functionality in order to allow it to be used without any dependencies (e.g. sound, network access, ...).
BeanInfoEmbryo: A BeanInfoEmbryo accumulates information about a Bean while it is in the process of being created, and then when you are done accumulating the information, the getBeanInfo() method may be called to create a BeanInfo object based on the information. This class is not well-synchronized. (It can be, it just isn't yet.)
EmptyBeanInfo: EmptyBeanInfo is a BeanInfo that discloses no information about the Bean and does not allow Introspection. The Introspector uses instances of this class to create empty BeanInfos, but it could also be used as a base class for BeanInfos that do not allow Introspection and provide only a little bit of information.
ScannerState: Provides the infrastructure for the state machine and the transition mechanism. Each states knows a set of successor. There can be one successor for every transition variant. Furthermore a state knows about a default successor which is taken when there is no special setup for a transition.
SimpleHandler: XML element handler that is specialized on tags that contains a simple string in their body which has to be parsed in a specific way. All of these tags have in common that they do not accept attributes. A warning is send to the parser's ExceptionListener when one or more attributes exist.
IntrospectionIncubator: IntrospectionIncubator takes in a bunch of Methods, and Introspects only those Methods you give it. See addMethod(Method) 55 for details which rules apply to the methods.
DefaultExceptionListener: The DefaultExceptionListener is the default implementation of the ExceptionListener interface. An instance of this class is used whenever the user provided no ExceptionListener instance on its own. The implementation just writes the exception's message to System.err .
AbstractObjectContext: AbstractObjectContext is the base for all Context implementations which create or provide a result object during their lifetime. This class provides the implementation for an indexed get and set method. But this does not mean that the result object supports these operation.
CollectionPersistenceDelegate: A PersistenceDelegate implementation that calls the no-argument constructor to create the Collection instance and uses an iterator to add all the objects it reaches through it. It is used for Set and List implementations.
Element: Element is the base class for the object tree elements. It provides the neccessary infrastructure every element subclass needs in order to interact with the gnu.java.beans.encoder.Root class.
MethodContext: MethodContext collects arguments for a method call and creates the result object using it. The method is called using the result object of the parent Context. When the result object is available methods can be called on it using sub-Contexts.