org.jfree.xml.util

## Class ObjectFactoryLoader

- java.lang.Object
- - org.jfree.xml.util.AbstractModelReader
  - - org.jfree.xml.util.ObjectFactoryLoader

- All Implemented Interfaces:
    ObjectFactory

      public class ObjectFactoryLoader
      extends AbstractModelReader
      implements ObjectFactory

  The object factory loader loads the xml specification for the generic handlers. The specification may be distributed over multiple files.

  This class provides the model management for the reader and writer. The instantiation of the handlers is done elsewhere.

  Author:
    TM

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ObjectFactoryLoader(java.net.URL resourceName)` Creates a new object factory loader for the given base file.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `endMultiplexMapping()` Finializes the multiplexer mapping.
    `protected void` | `endObjectDefinition()` Finializes the object definition.
    `GenericObjectFactory` | `getFactoryForClass(java.lang.Class c)` Returns a factory instance for the given class.
    `ManualMappingDefinition` | `getManualMappingDefinition(java.lang.Class c)` Returns the manual mapping definition for the given class, or null, if not manual definition exists.
    `MultiplexMappingDefinition` | `getMultiplexDefinition(java.lang.Class c)` Returns the multiplex definition for the given class, or null, if no such definition exists.
    `protected void` | `handleAttributeDefinition(java.lang.String name, java.lang.String attribName, java.lang.String handlerClass)` Handles an attribute definition.
    `protected void` | `handleConstructorDefinition(java.lang.String propertyName, java.lang.String parameterClass)` Handles a constructor definition.
    `protected void` | `handleElementDefinition(java.lang.String name, java.lang.String element)` Handles an element definition.
    `protected void` | `handleLookupDefinition(java.lang.String name, java.lang.String lookupKey)` Handles an lookup definition.
    `protected boolean` | `handleManualMapping(java.lang.String className, java.lang.String readHandler, java.lang.String writeHandler)` Handles a manual mapping definition.
    `protected void` | `handleMultiplexMapping(java.lang.String typeName, java.lang.String className)` Defines an entry for the multiplex mapping.
    `boolean` | `isGenericHandler(java.lang.Class c)` Checks, whether the factory has a description for the given class.
    `protected void` | `startMultiplexMapping(java.lang.String className, java.lang.String typeAttr)` Starts a multiplex mapping.
    `protected boolean` | `startObjectDefinition(java.lang.String className, java.lang.String register, boolean ignore)` Starts a object definition.

    - ### Methods inherited from class org.jfree.xml.util.AbstractModelReader

      `endIncludeHandling, endRootDocument, getCloseComment, getCommentHandler, getOpenComment, handleIgnoredProperty, loadClass, parseXml, parseXmlDocument, setCloseComment, setOpenComment, startIncludeHandling, startRootDocument`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### ObjectFactoryLoader

          public ObjectFactoryLoader(java.net.URL resourceName)
                              throws ObjectDescriptionException

      Creates a new object factory loader for the given base file.
      Parameters:
        `resourceName` - the URL of the initial specification file.
      Throws:
        `ObjectDescriptionException` - if the file could not be parsed.

  - ### Method Detail

    - #### startObjectDefinition

          protected boolean startObjectDefinition(java.lang.String className,
                                      java.lang.String register,
                                      boolean ignore)
                                           throws ObjectDescriptionException

      Starts a object definition. The object definition collects all properties of an bean-class and defines, which constructor should be used when creating the class.
      Specified by:
        `startObjectDefinition` in class `AbstractModelReader`
      Parameters:
        `className` - the class name of the defined object
        `register` - the (optional) register name, to lookup and reference the object later.
        `ignore` - ignore?
      Returns:
        true, if the definition was accepted, false otherwise.
      Throws:
        `ObjectDescriptionException` - if an unexpected error occured.

    - #### handleAttributeDefinition

          protected void handleAttributeDefinition(java.lang.String name,
                                       java.lang.String attribName,
                                       java.lang.String handlerClass)
                                            throws ObjectDescriptionException

      Handles an attribute definition. This method gets called after the object definition was started. The method will be called for every defined attribute property.
      Specified by:
        `handleAttributeDefinition` in class `AbstractModelReader`
      Parameters:
        `name` - the name of the property
        `attribName` - the xml-attribute name to use later.
        `handlerClass` - the attribute handler class.
      Throws:
        `ObjectDescriptionException` - if an error occured.

    - #### handleElementDefinition

          protected void handleElementDefinition(java.lang.String name,
                                     java.lang.String element)
                                          throws ObjectDescriptionException

      Handles an element definition. This method gets called after the object definition was started. The method will be called for every defined element property. Element properties are used to describe complex objects.
      Specified by:
        `handleElementDefinition` in class `AbstractModelReader`
      Parameters:
        `name` - the name of the property
        `element` - the xml-tag name for the child element.
      Throws:
        `ObjectDescriptionException` - if an error occurs.

    - #### handleLookupDefinition

          protected void handleLookupDefinition(java.lang.String name,
                                    java.lang.String lookupKey)
                                         throws ObjectDescriptionException

      Handles an lookup definition. This method gets called after the object definition was started. The method will be called for every defined lookup property. Lookup properties reference previously created object using the object's registry name.
      Specified by:
        `handleLookupDefinition` in class `AbstractModelReader`
      Parameters:
        `name` - the property name of the base object
        `lookupKey` - the register key of the referenced object
      Throws:
        `ObjectDescriptionException` - if an error occured.

    - #### endObjectDefinition

          protected void endObjectDefinition()
                                      throws ObjectDescriptionException

      Finializes the object definition.
      Specified by:
        `endObjectDefinition` in class `AbstractModelReader`
      Throws:
        `ObjectDescriptionException` - if an error occures.

    - #### handleConstructorDefinition

          protected void handleConstructorDefinition(java.lang.String propertyName,
                                         java.lang.String parameterClass)

      Handles a constructor definition. Only one constructor can be defined for a certain object type. The constructor will be filled using the given properties.
      Specified by:
        `handleConstructorDefinition` in class `AbstractModelReader`
      Parameters:
        `propertyName` - the property name of the referenced local property
        `parameterClass` - the parameter class for the parameter.

    - #### handleManualMapping

          protected boolean handleManualMapping(java.lang.String className,
                                    java.lang.String readHandler,
                                    java.lang.String writeHandler)
                                         throws ObjectDescriptionException

      Handles a manual mapping definition. The manual mapping maps specific read and write handlers to a given base class. Manual mappings always override any other definition.
      Specified by:
        `handleManualMapping` in class `AbstractModelReader`
      Parameters:
        `className` - the base class name
        `readHandler` - the class name of the read handler
        `writeHandler` - the class name of the write handler
      Returns:
        true, if the mapping was accepted, false otherwise.
      Throws:
        `ObjectDescriptionException` - if an unexpected error occured.

    - #### startMultiplexMapping

          protected void startMultiplexMapping(java.lang.String className,
                                   java.lang.String typeAttr)

      Starts a multiplex mapping. Multiplex mappings are used to define polymorphic argument handlers. The mapper will collect all derived classes of the given base class and will select the corresponding mapping based on the given type attribute.
      Specified by:
        `startMultiplexMapping` in class `AbstractModelReader`
      Parameters:
        `className` - the base class name
        `typeAttr` - the xml-attribute name containing the mapping key

    - #### handleMultiplexMapping

          protected void handleMultiplexMapping(java.lang.String typeName,
                                    java.lang.String className)
                                         throws ObjectDescriptionException

      Defines an entry for the multiplex mapping. The new entry will be activated when the base mappers type attribute contains this `typename` and will resolve to the handler for the given classname.
      Specified by:
        `handleMultiplexMapping` in class `AbstractModelReader`
      Parameters:
        `typeName` - the type value for this mapping.
        `className` - the class name to which this mapping resolves.
      Throws:
        `ObjectDescriptionException` - if an error occurs.

    - #### endMultiplexMapping

          protected void endMultiplexMapping()
                                      throws ObjectDescriptionException

      Finializes the multiplexer mapping.
      Specified by:
        `endMultiplexMapping` in class `AbstractModelReader`
      Throws:
        `ObjectDescriptionException` - if an error occurs.

    - #### isGenericHandler

          public boolean isGenericHandler(java.lang.Class c)

      Checks, whether the factory has a description for the given class.
      Specified by:
        `isGenericHandler` in interface `ObjectFactory`
      Parameters:
        `c` - the class to be handled by the factory.
      Returns:
        true, if an description exists for the given class, false otherwise.

    - #### getFactoryForClass

          public GenericObjectFactory getFactoryForClass(java.lang.Class c)

      Returns a factory instance for the given class. The factory is independent from all previously generated instances.
      Specified by:
        `getFactoryForClass` in interface `ObjectFactory`
      Parameters:
        `c` - the class
      Returns:
        the object factory.

    - #### getManualMappingDefinition

          public ManualMappingDefinition getManualMappingDefinition(java.lang.Class c)

      Returns the manual mapping definition for the given class, or null, if not manual definition exists.
      Specified by:
        `getManualMappingDefinition` in interface `ObjectFactory`
      Parameters:
        `c` - the class for which to check the existence of the definition
      Returns:
        the manual mapping definition or null.

    - #### getMultiplexDefinition

          public MultiplexMappingDefinition getMultiplexDefinition(java.lang.Class c)

      Returns the multiplex definition for the given class, or null, if no such definition exists.
      Specified by:
        `getMultiplexDefinition` in interface `ObjectFactory`
      Parameters:
        `c` - the class for which to check the existence of the multiplexer
      Returns:
        the multiplexer for the class, or null if no multiplexer exists.