Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.codehaus.aspectwerkz.compiler
Class AspectWerkzC

    java.lang.Object
      org.codehaus.aspectwerkz.compiler.AspectWerkzC

    public class AspectWerkzC

extends Object

AspectWerkzC allow for precompilation of class / jar / zip given a class preprocessor.

## Usage

         java [-Daspectwerkz.classloader.preprocessor={ClassPreProcessorImpl}] -cp [...]
         org.codehaus.aspectwerkz.compiler.AspectWerkzC [-verbose] [-haltOnError] [-verify] [-genjp] [-details] [-cp {additional cp i}]*  {target
         1} .. {target n}
           {ClassPreProcessorImpl} : full qualified name of the ClassPreProcessor implementation (must be in classpath)
              defaults to org.codehaus.aspectwerkz.transform.AspectWerkzPreProcessor
           {additional cp i} : additionnal classpath needed at compile time (eg: myaspect.jar)
              use as many -cp options as needed
              supports java classpath syntax for classpath separator: ; on windows, : on others
           {target i} : exploded dir, jar, zip files to compile
           Ant 1.5 must be in the classpath

## Classpath note

At the beginning of the compilation, all {target i} are added to the classpath automatically.
This is required to support caller side advices.

## Error handling

For each target i, a backup copy is written in ./_aspectwerkzc/i/target
Transformation occurs on original target class/dir/jar/zip file
On failure, target backup is restored and stacktrace is given
If -haltOnError was set, compilations ends and a complete rollback occurs on all targets, else a status report is printed at the end of the compilation, indicating SUCCESS or ERROR for each given target.
If -verify was set, all compiled class are verified during the compilation and an error is generated if the compiled class bytecode is corrupted. The error is then handled according to the -haltOnError option.

## Manifest.mf update

The Manifest.mf if present is updated wit the following:

- AspectWerkzC-created: date of the compilation
- AspectWerkzC-preprocessor: full qualified classname of the preprocessor used
- AspectWerkzC-comment: comments

Author:
  Alexandre Vasseur

Constructor Summary
`AspectWerkzC()` Construct a new Utility, restore the index for backup

Method Summary
`void` | `backup(File source, int index)` Backup source file in backup_dir/index/file.
`static void` | `compile(AspectWerkzC compiler, ClassLoader classLoader, String preProcessor, List classpath, List targets)` Runs the AspectWerkzC compiler for the `targets` files.
`boolean` | `compile(File source)` Compile given target.
`void` | `compileClass(File file, String packaging)` Compiles .class file using fileName as className and given packaging as package name
`void` | `compileJar(File file)` Compile all .class encountered in the .jar/.zip file.
`void` | `doCompile(File sourceFile, String prefixPackage)` Compile sourceFile.
`static void` | `doHelp()` Usage message
`Utility` | `getUtility()`
`static boolean` | `isJarFile(File source)` Test if file is a zip/jar file
`static void` | `main(String[] args)`
`void` | `postCompile(String message)` Delete backup dir at the end of all compilation
`void` | `restoreBackup()` Restore the backup registered
`void` | `setBackupDir(String backup)`
`void` | `setCompilationPath(File[] targets, ClassLoader parentLoader)` Set up the compilation path by building a URLClassLoader with all targets in
`void` | `setDetails(boolean details)`
`void` | `setGenJp(boolean genpJp)`
`void` | `setHaltOnError(boolean haltOnError)`
`void` | `setPreprocessor(String preprocessor)` Sets the ClassPreProcessor implementation to use.
`void` | `setVerbose(boolean verbose)`
`void` | `setVerify(boolean verify)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### AspectWerkzC

    public AspectWerkzC()

  Construct a new Utility, restore the index for backup

Method Detail

### setVerbose

    public void setVerbose(boolean verbose)

### setGenJp

    public void setGenJp(boolean genpJp)

### setHaltOnError

    public void setHaltOnError(boolean haltOnError)

### setVerify

    public void setVerify(boolean verify)

### setDetails

    public void setDetails(boolean details)

### setBackupDir

    public void setBackupDir(String backup)

### getUtility

    public Utility getUtility()

### setPreprocessor

    public void setPreprocessor(String preprocessor)
                         throws CompileException

  Sets the ClassPreProcessor implementation to use.

  The ClassLoader will be set to System ClassLoader when transform(className, byteCode, callerClassLoader) will be called to compile a class.

  Throws:
    `CompileException`

### backup

    public void backup(File source,
                       int index)

  Backup source file in backup_dir/index/file. The backupMap is updated for further rollback

### restoreBackup

    public void restoreBackup()

  Restore the backup registered

### postCompile

    public void postCompile(String message)

  Delete backup dir at the end of all compilation

### doCompile

    public void doCompile(File sourceFile,
                          String prefixPackage)
                   throws CompileException

  Compile sourceFile. If prefixPackage is not null, assumes it is the class package information.

  Handles :
  - directory recursively (exploded jar)
  - jar / zip file

  Throws:
    `CompileException`

### compileClass

    public void compileClass(File file,
                             String packaging)
                      throws CompileException

  Compiles .class file using fileName as className and given packaging as package name

  Throws:
    `CompileException`

### compileJar

    public void compileJar(File file)
                    throws CompileException

  Compile all .class encountered in the .jar/.zip file.

  The target.jar is compiled in the target.jar.aspectwerkzc and the target.jar.aspectwerkzc then overrides target.jar on success.

  Throws:
    `CompileException`

### compile

    public boolean compile(File source)

  Compile given target.

  Returns:
    false if process should stop

### setCompilationPath

    public void setCompilationPath(File[] targets,
                                   ClassLoader parentLoader)

  Set up the compilation path by building a URLClassLoader with all targets in

  Parameters:
    `targets` - to add to compilationLoader classpath
    `parentLoader` - the parent ClassLoader used by the new one

### isJarFile

    public static boolean isJarFile(File source)

  Test if file is a zip/jar file

### doHelp

    public static void doHelp()

  Usage message

### compile

    public static void compile(AspectWerkzC compiler,
                               ClassLoader classLoader,
                               String preProcessor,
                               List classpath,
                               List targets)

  Runs the AspectWerkzC compiler for the `targets` files.

  Parameters:
    `compiler` - a configured `AspectWerkzC`
    `classLoader` - the class loader to be used
    `preProcessor` - fully qualified name of the preprocessor class. If `null` than the default is used (`org.codehaus.aspectwerkz.transform.AspectWerkzPreProcessor`)
    `classpath` - list of Files representing the classpath (List)
    `targets` - the list of target files (List)

### main

    public static void main(String[] args)

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2002-2005 Jonas Bonér, Alexandre Vasseur. All Rights Reserved.