structureddocumentfactory.java

jxta_src_2.41b jxta 2.41b 最新版源码 from www.jxta.org

            return false;
        }
    }
    
    /**
     *  Used by ClassFactory methods to get the mapping of Mime Types to
     *  constructors.
     *
     *  @return Hastable the hashtable containing the mappings.
     **/
    protected Map getAssocTable() {
        return encodings;
    }
    
    /**
     * Used by ClassFactory methods to ensure that all keys used with the
     * mapping are of the correct type.
     *
     *  @return Class object of the key type.
     **/
    protected Class getClassForKey() {
        return java.lang.String.class;
    }
    
    /**
     *  Used by ClassFactory methods to ensure that all of the instantiators
     *  which are registered with this factory have the correct interface.
     *
     *  @return Class object of the "Factory" type.
     **/
    protected Class getClassOfInstantiators() {
        // our key is the doctype names.
        return Instantiator.class;
    }
    
    /**
     *  Register a class with the factory from its class name. 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 regiestered.
     *  @return boolean true if the class was registered otherwise false.
     **/
    protected boolean registerAssoc( String className ) {
        boolean registeredSomething = false;
        
        //LOG.debug( "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.debug( "   Registering Type : " + mimeTypes[eachType].getMimeMediaType() );
                
                registeredSomething |= registerInstantiator( 
                    mimeTypes[eachType],
                    instantiator );
            }
        }
        catch( Exception all ) {
            if (LOG.isEnabledFor(Level.WARN)) {
                LOG.warn( "Failed to register '" + className + "'", all );
            }
        }
        
        return registeredSomething;
    }
    
    /**
     *  Returns the prefered extension for a given mime-type. If there is no
     *  mapping or no prefered extension for this mimetype then null 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 ) {
        return (String) factory.mimeToExt.get( mimetype.getMimeMediaType() );
    }
    
    /**
     *  Returns the prefered mime-type for a given file extension. If there is
     * no mapping then null 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 ) {
        MimeMediaType result = null;
        String fromMap = (String) factory.extToMime.get( extension );
        
        if( null != fromMap ) {
            result = new MimeMediaType( fromMap );
        }
        
        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.getMimeMediaType(),
        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().getMimeMediaType() );
                    
                    factory.mimeToExt.put(
                    extensions[eachExt].getMimeMediaType().getMimeMediaType(),
                    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 ) {
        if( !factory.loadedProperty ) {
            factory.loadedProperty = factory.doLoadProperty();
        }
        
        Instantiator instantiator =
        (Instantiator) factory.getInstantiator( mimetype.getMimeMediaType() );
        
        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 registerd.
     **/
    public static StructuredDocument newStructuredDocument( MimeMediaType mimetype,
    String doctype,
    String value ) {
        if( !factory.loadedProperty ) {
            factory.loadedProperty = factory.doLoadProperty();
        }
        
        Instantiator instantiator =
        (Instantiator) factory.getInstantiator( mimetype.getMimeMediaType() );
        
        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 registerd.
     **/
    public static StructuredDocument newStructuredDocument( MimeMediaType mimetype,
    InputStream stream )
    throws IOException {
        if( !factory.loadedProperty ) {
            factory.loadedProperty = factory.doLoadProperty();
        }
        
        Instantiator instantiator =
        (Instantiator) factory.getInstantiator( mimetype.getMimeMediaType() );
        
        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 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 registerd.
     * @throws UnsupportedOperationException if the mime-type provided is not
      * a text oriented mimetype.
     **/
    public static StructuredDocument newStructuredDocument( MimeMediaType mimetype,
    Reader reader )
    throws IOException {
        if( !factory.loadedProperty ) {
            factory.loadedProperty = factory.doLoadProperty();
        }
        
        Instantiator instantiator =
        (Instantiator) factory.getInstantiator( mimetype.getMimeMediaType() );
        
        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 (LOG.isEnabledFor(Level.WARN)) {
                LOG.warn( "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 registerd.
     **/
    public static StructuredDocument newStructuredDocument( MessageElement element ) 
    throws IOException {
        if( !factory.loadedProperty ) {
            factory.loadedProperty = factory.doLoadProperty();
        }
        
        Instantiator instantiator =
        (Instantiator) factory.getInstantiator( element.getMimeType().getMimeMediaType() );
        
        if( (instantiator instanceof TextInstantiator) && (element instanceof TextMessageElement) ) {
            return ((TextInstantiator)instantiator).newInstance( element.getMimeType(), ((TextMessageElement)element).getReader() );
        } else {
            return instantiator.newInstance( element.getMimeType(), element.getStream() );
        }
    }
}