Changeset 7629


Ignore:
Timestamp:
02/21/11 22:07:28 (8 years ago)
Author:
curtis
Message:

Add separate settings for library vs. classpath JARs.

Library JARs are scanned, and their classes wrapped as C++ proxies,
whereas classpath JARs are added to the classpath but not wrapped.

With these changes, cppwrap can now successfully wrap projects with
dependencies.

Location:
trunk/projects
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/projects/cppwrap-maven-plugin/src/main/java/loci/maven/plugin/cppwrap/CppWrapMojo.java

    r7627 r7629  
    8181         * 
    8282         * @parameter expression="${cppwrap.headerFile}" 
    83          *   default-value="src/main/cppwrap/header.txt" 
     83         *   default-value="LICENSE.txt" 
    8484         */ 
    8585        private File headerFile; 
     
    9999                final String projectId = artifactId.replaceAll("[^\\w\\-]", "_"); 
    100100                final String projectName = project.getName(); 
    101                 final List<String> libraryPaths = getLibraryPaths(); 
     101                final List<String> libraryJars = getLibraryJars(); 
     102                final List<String> classpathJars = getClasspathJars(); 
    102103                final String conflictsPath = conflictsFile.exists() ? 
    103104                        conflictsFile.getPath() : null; 
     
    114115                jar2lib.setProjectId(projectId); 
    115116                jar2lib.setProjectName(projectName); 
    116                 jar2lib.setLibraryPaths(libraryPaths); 
     117                jar2lib.setLibraryJars(libraryJars); 
     118                jar2lib.setClasspathJars(classpathJars); 
    117119                jar2lib.setConflictsPath(conflictsPath); 
    118120                jar2lib.setHeaderPath(headerPath); 
     
    129131        } 
    130132 
    131         private List<String> getLibraryPaths() throws MojoExecutionException { 
    132                 final List<String> libraryPaths = new ArrayList<String>(); 
     133        private List<String> getLibraryJars() throws MojoExecutionException { 
     134                final List<String> jars = new ArrayList<String>(); 
    133135 
    134136                // add project artifact 
     
    137139                        throw new MojoExecutionException("Must execute package target first."); 
    138140                } 
    139                 libraryPaths.add(projectArtifact.getPath()); 
     141                jars.add(projectArtifact.getPath()); 
     142 
     143                return jars; 
     144        } 
     145 
     146        private List<String> getClasspathJars() { 
     147                final List<String> jars = new ArrayList<String>(); 
    140148 
    141149                // add project runtime dependencies 
    142150                final List<Artifact> artifacts = project.getRuntimeArtifacts(); 
    143151                for (final Artifact classPathElement : artifacts) { 
    144                         libraryPaths.add(classPathElement.getFile().getPath()); 
     152                        jars.add(classPathElement.getFile().getPath()); 
    145153                } 
    146154 
    147                 return libraryPaths; 
     155                return jars; 
    148156        } 
    149157 
  • trunk/projects/jar2lib/src/main/java/loci/jar2lib/Jar2Lib.java

    r7626 r7629  
    7070  private String projectId; 
    7171  private String projectName; 
    72   private List<String> jarPaths; 
     72  private List<String> libraryJars; 
     73  private List<String> classpathJars; 
    7374  private String conflictsPath; 
    7475  private String headerPath; 
     
    7879 
    7980  public Jar2Lib() { 
    80     jarPaths = new ArrayList<String>(); 
     81    libraryJars = new ArrayList<String>(); 
     82    classpathJars = new ArrayList<String>(); 
    8183  } 
    8284 
     
    9597    this.projectName = projectName; 
    9698  } 
    97   public List<String> getLibraryPaths() { 
    98     return jarPaths; 
    99   } 
    100   public void setLibraryPaths(List<String> jarPaths) { 
    101     this.jarPaths = jarPaths; 
     99  public List<String> getLibraryJars() { 
     100    return libraryJars; 
     101  } 
     102  public void setLibraryJars(List<String> libraryJars) { 
     103    this.libraryJars = libraryJars; 
     104  } 
     105  public List<String> getClasspathJars() { 
     106    return classpathJars; 
     107  } 
     108  public void setClasspathJars(List<String> classpathJars) { 
     109    this.classpathJars = classpathJars; 
    102110  } 
    103111  public String getConflictsPath() { 
     
    122130  /** Parses the settings from the given command line arguments. */ 
    123131  public void parseArgs(String[] args) { 
    124     jarPaths = new ArrayList<String>(); 
     132    projectId = args.length >= 1 ? args[0] : null; 
     133    projectName = args.length >= 2 ? args[1] : null; 
     134    libraryJars = new ArrayList<String>(); 
     135    classpathJars = new ArrayList<String>(); 
    125136    conflictsPath = null; 
    126137    headerPath = null; 
    127138    outputPath = null; 
    128     projectId = args.length >= 1 ? args[0] : null; 
    129     projectName = args.length >= 2 ? args[1] : null; 
    130139    for (int i = 2; i < args.length; i++) { 
    131140      final String arg = args[i]; 
     
    143152      } 
    144153      else if (arg.startsWith("-")) die("Unknown flag: " + arg); 
    145       else jarPaths.add(arg); 
    146     } 
    147     if (projectId == null || projectName == null || jarPaths.size() == 0) { 
     154      else libraryJars.add(arg); 
     155    } 
     156    if (projectId == null || projectName == null || libraryJars.size() == 0) { 
    148157      die("Usage: java " + getClass().getName() + " projectId projectName\n" + 
    149158        "  library.jar [library2.jar ...]\n" + 
     
    216225    final File includeDir = new File(outputPath, "include"); 
    217226    if (!includeDir.exists()) includeDir.mkdirs(); 
    218     for (String jarPath : jarPaths) { 
     227    for (String jarPath : libraryJars) { 
    219228      final File jarFile = new File(jarPath); 
    220229      log("--> Generating header for " + jarFile.getName()); 
     
    268277    autoProxyArgs.add(path(proxiesIncludeDir)); 
    269278    autoProxyArgs.add(path(proxiesSourceDir)); 
    270     autoProxyArgs.add(classpath(jarPaths)); 
     279    List<String> allJars = new ArrayList<String>(); 
     280    allJars.addAll(libraryJars); 
     281    allJars.addAll(classpathJars); 
     282    autoProxyArgs.add(classpath(allJars)); 
    271283    autoProxyArgs.add("-mindep"); 
    272284    if (isWindows) autoProxyArgs.add("-exportsymbols"); 
     
    326338    final String path = file.getAbsolutePath(); 
    327339    // NB: Use forward slashes even on Windows. 
    328     return path.replaceAll(File.separator, "/"); 
     340    return path.replaceAll("\\\\", "/"); 
    329341  } 
    330342 
     
    399411 
    400412  /** Builds a classpath corresponding to the given list of JAR files. */ 
    401   private static String classpath(List<String> jarPaths) 
     413  private static String classpath(List<String> libraryJars) 
    402414    throws UnsupportedEncodingException 
    403415  { 
     
    405417    final String jrePath = findRuntime(); 
    406418    sb.append(jrePath); 
    407     for (String jarPath : jarPaths) { 
     419    for (String jarPath : libraryJars) { 
    408420      sb.append(File.pathSeparator); 
    409421      sb.append(jarPath); 
Note: See TracChangeset for help on using the changeset viewer.