main page modules namespaces classes files
Gecode/J home

LibLoader.java

Go to the documentation of this file.

/*
** Written by Gregory L. Guerin, April 2002.
** Freely released AS-IS AND WITHOUT WARRANTY OF ANY KIND into the public domain.
*/

package glguerin.util;

import java.lang.reflect.*;
import java.io.*;


// --- Revision History ---
// 29Apr2002 GLG  create a work-around for Cocoa-Java's obstinate JNI-lib stupidity
// 02May2002 GLG  revise how getTinker() decides which imp to return
// 02May2002 GLG  copy to tenjni package
// 03May2002 GLG  revise to keep a thread-safe singleton
// 21May2002 GLG  name changes
// 05Nov2002 GLG  rework substantially, calling NSBundle with reflection
// 18Nov2002 GLG  add diagnostics to System.err, and null-File checks
// 05Dec2002 GLG  revise how property is used in makeLoader()
// 10Dec2002 GLG  change package and properties
// 09Aug2003 GLG  change UnsatisfiedLinkError message in load()


public class LibLoader
{
        public static boolean isVerbose = Boolean.getBoolean( "glguerin.util.LibLoader.debug" );


        private static LibLoader knownLoader;


        public static synchronized LibLoader
        getLoader()
        {
                if ( knownLoader == null )
                {
                        knownLoader = makeLoader();
//                      System.err.println( "# LibLoader: " + knownLoader.getClass() + ", using " + knownLoader );
                }
                return ( knownLoader );
        }


        public static LibLoader
        makeLoader()
        {
                // Look for a system property overtly specifying a class name.
                // Absent such a property, the default is to use this LibLoader, which has a
                // fallback strategy that can call a Cocoa NSBundle using reflection.
                String className = System.getProperty( "glguerin.util.LibLoader.imp", "" );

                if ( className != null  &&  className.length() > 0 )
                {
                        try
                        {
                                // If any of this throws any kind of exception, return a vanilla LibLoader instead.
                                return ( (LibLoader) Class.forName( className ).newInstance() );
                        }
                        catch ( ThreadDeath mustRethrow )
                        {  throw mustRethrow;  }
                        catch ( Throwable everythingElse )
                        {  /* FALL THROUGH */  }
                }

                // Return a vanilla LibLoader instance, hoping for the best.
                return ( new LibLoader() );
        }




        protected final File dirFallback;

        public
        LibLoader()
        {
                dirFallback = makeFallbackDir();
                blab();
        }

        protected void
        blab()
        {
                if ( isVerbose )
                        System.err.println( "# LibLoader dir: " + dirFallback );
        }
        

        public void
        loadLibrary( String libName )
        {
                // We're told not to catch Errors, but there's no other way to find out if a linkage failed.
                // Failures other than UnsatisfiedLinkError get thrown up to caller.
                try
                {  System.loadLibrary( libName );  }
                catch ( UnsatisfiedLinkError failure )
                {  this.load( libName, dirFallback );  }  // use fallback scheme.
        }

        protected void
        load( String libName, File location )
        {
                if ( location == null )
                        throw new UnsatisfiedLinkError( "Don't know how to load JNI library: " + libName );

                // This hand-made scheme follows the usual Mac OS X Java JNI-lib naming pattern.
                // Under Java 2 it could use System.mapLibraryName().
                String libPath = new File( location, "lib" + libName + ".jnilib" ).getAbsolutePath();

                if ( isVerbose )
                        System.err.println( "# LibLoader: trying " + libPath );

                System.load( libPath );
        }


        protected File
        makeFallbackDir()
        {
                try
                {
                        // Both mainBundle() and resourcePath() take no args.
                        // The empty Class[] represents the method signature.
                        // The empty Object[] represents the invoked method's args.
                        Class[] noArgs = new Class[ 0 ];
                        Object[] nothing = new Object[ 0 ];

                        // Try to load an NSBundle class and reflectively invoke its methods.
                        // NSBundle.mainBundle() is a public static method returning an NSBundle.
                        // NSBundle.resourcePath() is a public instance method called on the NSBundle instance.
                        Class bundleClass = Class.forName( "com.apple.cocoa.foundation.NSBundle" );

                        if ( isVerbose )
                                System.err.println( "# LibLoader got NSBundle: " + bundleClass );

                        // First, get the NSBundle.  A static invocation doesn't care what the target object is.
                        // Second, use the NSBundle to invoke the bundlePath() method.
                        Object theNSBundle = bundleClass.getMethod( "mainBundle", noArgs ).invoke( null, nothing );
                        Object thePath = bundleClass.getMethod( "resourcePath", noArgs ).invoke( theNSBundle, nothing );

                        // The resultant value of thePath should be a String holding a full pathname.
                        // Don't cast it, just use its toString() method to assemble an appropriate File.
                        return ( new File( thePath.toString(), "Java" ) );
                }
                catch ( ClassNotFoundException why )
                {  /* FALL THRU */  }
                catch ( NoSuchMethodException why )
                {  /* FALL THRU */  }
                catch ( IllegalAccessException why )
                {  /* FALL THRU */  }
                catch ( IllegalArgumentException why )
                {  /* FALL THRU */  }
                catch ( InvocationTargetException why )
                {  /* FALL THRU */  }

                // Here's where a "last-chance directory" can be returned.
                // One option is the "user.dir" property, or ".".
                // There are security implications to using the current directory as the location of native-code libraries.
                // Another slightly safer option would be the "java.home" property, or some location therein.
                // I've avoided all those in favor of simply returning null, so load() will fail
                // if there's no NSBundle available.
                return ( null );
        }


        public String
        toString()
        {  return ( "System.loadLibrary()" + File.pathSeparator + dirFallback );  }

}