structureddocumentfactory.java

JXTA&#8482 is a set of open, generalized peer-to-peer (P2P) protocols that allow any networked devi

     */
    private final Map<String, MimeMediaType>  extToMime = new HashMap<String, MimeMediaType>();
    
    /**
     *  This is the map of mime-types to extensions used by
     *  {@link #getFileExtensionForMimeType(MimeMediaType mimetype) }
     */
    private final Map<MimeMediaType, String>  mimeToExt = new HashMap<MimeMediaType, String>();
    
    /**
     *  If true then the pre-defined set of StructuredDocument sub-classes has
     *  been registered from the property containing them.
     */
    private boolean loadedProperty = false;
    
    /**
     *  Private constructor. This class is not meant to be instantiated except
     *  by itself.
     *
     */
    private StructuredDocumentFactory() {}
    
    /**
     *  Registers the pre-defined set of StructuredDocument sub-classes so that
     *  this factory can construct them.
     *
     *  @return true if at least one of the StructuredDocument sub-classes could
     *  be registered otherwise false.
     */
    private synchronized boolean loadProviders() {
        if (factory.loadedProperty) {
            return true;
        }

        factory.loadedProperty = registerProviders(StructuredDocument.class.getName());
        
        return factory.loadedProperty;
    }
    
    /**
     *  {@inheritDoc}
     */
    @Override
    protected Map<MimeMediaType, Instantiator> getAssocTable() {
        return encodings;
    }
    
    /**
     *  {@inheritDoc}
     */
    @Override
    protected Class<MimeMediaType> getClassForKey() {
        return MimeMediaType.class;
    }
    
    /**
     *  {@inheritDoc}
     */
    @Override
    protected Class<Instantiator> getClassOfInstantiators() {
        // our key is the doctype names.
        return Instantiator.class;
    }
    
    /**
     *  {@inheritDoc}
     *
     *  <p/>We override the standard implementation to get the MIME type from
     *  the class and use that as the key to register the class with the factory.
     *
     *  @param className The class name which will be registered.
     *  @return boolean true if the class was registered otherwise false.
     */
    @Override
    protected boolean registerAssoc(String className) {
        boolean registeredSomething = false;
        
        LOG.finer("Registering : " + className);
        
        try {
            Class docClass = Class.forName(className);
            
            Instantiator instantiator = (Instantiator) docClass.getField("INSTANTIATOR").get(null);
            
            MimeMediaType[] mimeTypes = instantiator.getSupportedMimeTypes();
            
            for (int eachType = 0; eachType < mimeTypes.length; eachType++) {
                LOG.finer("   Registering Type : " + mimeTypes[eachType].getMimeMediaType());
                registeredSomething |= registerInstantiator(mimeTypes[eachType], instantiator);
            }
        } catch (Exception all) {
            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.log(Level.WARNING, "Failed to register \'" + className + "\'", all);
            }
        }
        
        return registeredSomething;
    }
    
    /**
     *  Returns the preferred extension for a given mime-type. If there is no
     *  mapping or no preferred extension for this MIME type then <tt>null</tt> is
     *  returned.
     *
     *  @param mimetype the MimeMediaType we wish to know the file extension for.
     *  @return String containing the extension or null for mime-types with no
     *  known association.
     */
    public static String getFileExtensionForMimeType(MimeMediaType mimetype) {
        factory.loadProviders();
        
        return factory.mimeToExt.get(mimetype.getBaseMimeMediaType());
    }
    
    /**
     *  Returns the preferred mime-type for a given file extension. If there is
     *  no mapping then <tt>null</tt> is returned.
     *
     *  @param extension The extension we wish to know the mime-type for.
     *  @return MimeMediaType associated with this file extension.
     */
    public static MimeMediaType getMimeTypeForFileExtension(String extension) {
        factory.loadProviders();
        
        MimeMediaType result = factory.extToMime.get(extension);
        
        return result;
    }
    
    /**
     * Register an instantiator object a mime-type of documents to be
     * constructed.
     *
     * @param mimetype   the mime-type associated.
     * @param instantiator the instantiator that wants to be registered..
     * @return boolean true   if the instantiator for this mime-type is now
     * registered. If there was already an instantiator this mime-type then
     * false will be returned.
     * @throws SecurityException   there were permission problems registering
     *  the instantiator.
     */
    public static boolean registerInstantiator(MimeMediaType mimetype, Instantiator instantiator) {
        boolean registered = factory.registerAssoc(mimetype.getBaseMimeMediaType(), instantiator);
        
        if (registered) {
            Instantiator.ExtensionMapping[] extensions = instantiator.getSupportedFileExtensions();
            
            for (int eachExt = 0; eachExt < extensions.length; eachExt++) {
                if (null != extensions[eachExt].getMimeMediaType()) {
                    factory.extToMime.put(extensions[eachExt].getExtension(), extensions[eachExt].getMimeMediaType().intern());
                    
                    factory.mimeToExt.put(extensions[eachExt].getMimeMediaType(), extensions[eachExt].getExtension());
                    
                    // And the base version.
                    factory.mimeToExt.put(extensions[eachExt].getMimeMediaType().getBaseMimeMediaType(), extensions[eachExt].getExtension());
                }
            }
        }
        
        return registered;
    }
    
    /**
     * Constructs an instance of {@link StructuredDocument} matching
     * the mime-type specified by the <CODE>mimetype</CODE> parameter. The
     * <CODE>doctype</CODE> parameter identifies the base type of the
     * {@link StructuredDocument}.
     *
     * @param mimetype Specifies the mime media type to be associated with
     *  the {@link StructuredDocument} to be created.
     * @param doctype Specifies the root type of the {@link StructuredDocument}
     *  to be created.
     * @return StructuredDocument The instance of {@link StructuredDocument}
     *  or null if it could not be created.
     * @throws NoSuchElementException invalid mime-media-type
     */
    public static StructuredDocument newStructuredDocument(MimeMediaType mimetype, String doctype) {
        factory.loadProviders();
        
        Instantiator instantiator = factory.getInstantiator(mimetype.getBaseMimeMediaType());
        
        return instantiator.newInstance(mimetype, doctype);
    }
    
    /**
     * Constructs an instance of {@link StructuredDocument} matching
     * the mime-type specified by the <CODE>mimetype</CODE> parameter. The
     * <CODE>doctype</CODE> parameter identifies the base type of the
     * {@link StructuredDocument}. Value supplies a value for the root
     * element.
     *
     * @param mimetype Specifies the mime media type to be associated with
     *  the {@link StructuredDocument} to be created.
     * @param doctype Specifies the root type of the {@link StructuredDocument}
     *  to be created.
     * @param value Specifies a value for the root element.
     * @return StructuredDocument The instance of {@link StructuredDocument}
     *  or null if it could not be created.
     * @throws NoSuchElementException if the mime-type has not been registered.
     */
    public static StructuredDocument newStructuredDocument(MimeMediaType mimetype, String doctype, String value) {
        factory.loadProviders();
        
        Instantiator instantiator = factory.getInstantiator(mimetype.getBaseMimeMediaType());
        
        return instantiator.newInstance(mimetype, doctype, value);
    }
    
    /**
     * Constructs an instance of {@link StructuredDocument} matching
     * the mime-type specified by the <CODE>mimetype</CODE> parameter. The
     * <CODE>doctype</CODE> parameter identifies the base type of the
     * {@link StructuredDocument}.
     *
     * @param mimetype Specifies the mime media type to be associated with the
     *  {@link StructuredDocument} to be created.
     * @param stream Contains an InputStream from which the document will be
     *  constructed.
     * @return StructuredDocument The instance of {@link StructuredDocument}
     *  or null if it could not be created.
     * @throws IOException If there is a problem reading from the stream.
     * @throws NoSuchElementException if the mime-type has not been registered.
     */
    public static StructuredDocument newStructuredDocument(MimeMediaType mimetype, InputStream stream) throws IOException {
        factory.loadProviders();
        
        Instantiator instantiator = factory.getInstantiator(mimetype.getBaseMimeMediaType());
        
        return instantiator.newInstance(mimetype, stream);
    }
    
    /**
     * Constructs an instance of {@link StructuredDocument} matching
     * the mime-type specified by the <CODE>mimetype</CODE> parameter. The
     * <CODE>doctype</CODE> parameter identifies the base type of the
     * {@link StructuredDocument}.
     *
     * @param mimetype Specifies the mime media type to be associated with the
     * {@link StructuredDocument} to be created.
     * @param reader A Reader from which the document will be constructed.
     * @return StructuredDocument The instance of {@link StructuredDocument}
     * or {@code null} if it could not be created.
     * @throws IOException If there is a problem reading from the stream.
     * @throws NoSuchElementException if the mime-type has not been registered.
     * @throws UnsupportedOperationException if the mime-type provided is not
     * a text oriented MIME type.
     */
    public static StructuredDocument newStructuredDocument(MimeMediaType mimetype, Reader reader) throws IOException {
        factory.loadProviders();
        
        Instantiator instantiator = factory.getInstantiator(mimetype.getBaseMimeMediaType());
        
        if (!(instantiator instanceof TextInstantiator)) {
            // XXX 20020502 [e-mail] we could probably do something
            // really inefficient that would allow it to work, but better not to.
            // if ReaderInputStream existed, it would be easy to do.
            if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
                LOG.warning( "Document Class \'" + instantiator.getClass().getName() + "\' associated with \'" + mimetype 
                    + "\' is not a text oriented document");
            }
            
            throw new UnsupportedOperationException( "Document Class '" + instantiator.getClass().getName() 
                    + "' associated with '" + mimetype + "' is not a text oriented document");
        }
        
        return ((TextInstantiator) instantiator).newInstance(mimetype, reader);
    }
    
    /**
     * Constructs an instance of {@link StructuredDocument} based upon the
     * content of the provided message element.
     *
     * @param element The message element from which to create the document.
     * @return StructuredDocument The instance of {@link StructuredDocument}
     *  or null if it could not be created.
     * @throws IOException If there is a problem reading from the stream.
     * @throws NoSuchElementException if the mime-type has not been registered.
     */
    public static StructuredDocument newStructuredDocument(MessageElement element) throws IOException {
        factory.loadProviders();
        
        Instantiator instantiator = factory.getInstantiator(element.getMimeType().getBaseMimeMediaType());
        
        if ((instantiator instanceof TextInstantiator) && (element instanceof TextMessageElement)) {
            return ((TextInstantiator) instantiator).newInstance(element.getMimeType(), ((TextMessageElement) element).getReader());
        } else {
            return instantiator.newInstance(element.getMimeType(), element.getStream());
        }
    }
}