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

Quick Search    Search Deep

org.progeeks.meta.* (86)org.progeeks.util.* (10)

Package Samples:

org.progeeks.meta.beans
org.progeeks.meta.format
org.progeeks.meta.swing.editor
org.progeeks.meta.swing
org.progeeks.meta.util
org.progeeks.meta.xml
org.progeeks.meta
org.progeeks.util.beans
org.progeeks.util.log
org.progeeks.util.swing
org.progeeks.util

Classes:

AbstractListMutator: Abstract implementation of ListMutator providing basic functionality for dealing with List values. Subclasses are required to implement at least the get(int) and size() methods for read-only access. For a modifiable list, set(int, object) should be overriden and for a resizble list, add(object) and remove(int) should be overridden. Otherwise, these methods throw UnsupportedOperation exception. To support change notification, subclasses must provide an implementation of the firePropertyChangeEvent() method. Note: this may eventually move to the meta package and be re-extended here just to provide ...
BeanInspector: Provides reflection utilities for a single bean class. This internally caches bean methods so that they don't have to be looked up repeatedly. In addition, it can provide additional info about the class that is important to know about things like multi-valued properties and such. Note: This class functions different than the org.progeeks.util.Inspector class and may one day replace it. This class provides an object per class where as the Inspector class provides and object per object.
ListMutator: Extends PropertyMutator to provide access to the members of a multi-valued property value. This allows the mutator to properly manage list change notifications even if the actual storage object does not. For example, standard java.util.List based properties can't be expected to manage the complexities of element change notification, insertions, etc.. The mutator wraps this support around the real value.
PropertyType: Represents a property type of a meta-object. This is an additional abstraction on top of the Java Class object to provide more flexible subtyping. All PropertyTypes will have a base Java class that they sub-type or represent. This is useful as a fall-back when a more specific handler is not available. Additionally, PropertyTypes can be used to test an Object's membership in the type family.
Log: System logging class. Allows for multiple log levels and a hierarchy of named categories. Each category can have its own log format. Example code: public class MyTestClass { static Log log = Log.getLog( MyTestClass.class ); public void someMethod() { log.debug( "Entering someMethod()" ); log.info( "Some operation being performed." ); } }
DeferredPropertyType: Represents an unresolved property type of a meta-object. This is to support deferred resolution of property types within a meta-class. The actual functionality of the PropertyType implementation throws UnsupportedOperationExceptions since these operations cannot be done without resolving the type. When the type has been resolved within the meta-class it will be replaced with the real type.
DefaultMetaTable: A default implementation of the MetaTable interface. This meta-table implementation contains an internal list of objects. If these objects are meta-objects then they are access directly. Otherwise, they are wrapped in meta-objects using the meta-kit provided. Optionally a list of property names can be provided or the table will pull the property names from the specified meta-class.
DefaultListMutator: A default implementation of ListMutator that will work with any MetaObject, given certain restrictions. It can be used as an implementation on its own or subclassed to provide performance improvements in metakit implementation specific cases. Subclasses must implement the firePropertyChangeEvent() event method to support delivery of list change events.
AbstractMetaObject: An abstract meta-object implementation making it easier to create kit-specific meta-object adapters. Hooks are provided to allow subclasses to override specific functionality that may be important to a meta-kit implementation. Subclasses must provide, at the minimum, getProperty() and setProperty() methods.
MetaClassRegistry: A registry of MetaClasses that can be looked up by name. The MetaClassRegistry acts as sort of a class-loader in meta-space. Each MetaClass knows which class registry it belongs to and can use this information to look up information about related classes.
FormatRegistry: Matches types for PropertyFormats. This is essentially a thin wrapper around a TypeRegistry containing property format objects. This class can provide advanced behavior in some cases by automatically resolving formatters for multi-value types and such.
MetaObjectFactory: Interface that meta-object implementations can implement to provide toolkit-specific meta-object creation. This is useful to for allowing the generic ui/application to create new objects that will be used as values for meta-object valued fields.
MultiColumnPanelUIFactory: Factory for creating MultiColumnPanelUIs that can act as either renderers or editors. This factory implements both editor factory and renderer factory and can therefore be registered as either or both as needed.
ListPropertyChangeEvent: An extension to the standard PropertyChangeEvent that provides information about changes to the list. Standard property change events don't handle this very well since the list object itself will be the same.
DefaultPropertyMutator: A default implementation of PropertyMutator that will work with any MetaObject. It can be used as an implementation on its own or subclassed to provide performance improvements in metakit specific cases.
DefaultPropertyFormat: Default implementation for converting objects to and from text data. This assumes that the associated class has a useful toString() method that can also be passed to a String arg constructor.
DefaultListPropertyFormat: Default implementation for converting a list of objects to and from text data. This assumes that the values' have a useful toString() method. This formatter can only be used for rendering.
ListPropertyType: Represents an ordered list of values such that they can be referenced by index number. ListPropertyType is a container type and so also provides information about the type of its members.
MetaKit: Abstraction of a meta-object implementation layer. This provides some direct access to the adapter layer that may be necessary when interacting with certain meta-object property values.
ContainerEditorFactory: Factory for ContainerEditors. ContainerEditors may have various things that can be configured about them. Also in some cases it is useful for them to have access to a FactoryRegistry.
MetaClass: Describes the properties associated with a meta-object. MetaClass objects must be created through the factory methods provided by the MetaClassRegistry to which they will belong.
ListEditorFactory: Factory for ListEditors. ListEditors may have various things that can be configured about them. Also in some cases it is useful for them to have access to a FactoryRegistry.
XmlPrintWriter: Extends the functionality of the IndentPrintWriter to keep track of tag state and provide attribute support, etc.. Also, all output is encoded as appropriate for its context.
MetaObjectUI: A component that provides rendering or editing support for an instance of a specific MetaClass. This is a wrapper around a component that can be stuffed with a meta-object.

Home | Contact Us | Privacy Policy | Terms of Service