All Packages from de.hunsicker.io.* to de.hunsicker.util.*

Home >> All >> de >> hunsicker

•

de.hunsicker.io.* (7)

•

de.hunsicker.jalopy.* (274)

•

de.hunsicker.swing.* (7)

•

de.hunsicker.util.* (12)

Package Samples:

• de.hunsicker.jalopy.swing.syntax: Provides some building blocks to make implementing a Swing-based, graphical user interface for the Jalopy code convention settings easy.
• de.hunsicker.jalopy.swing: Contains the main classes to directly interact with the Jalopy formatting engine.
• de.hunsicker.jalopy: Contains the main classes to directly interact with the Jalopy formatting engine.
• de.hunsicker.jalopy.language: Contains all classes related to the task of language recognition and processing.
• de.hunsicker.jalopy.plugin: Supplies the Plug-in hook for the integration with other Java applications.
• de.hunsicker.jalopy.storage: The Jalopy runtime and persistant state storage and configuration facility.
• de.hunsicker.jalopy.plugin.jedit.option: Contains the jEdit Plug-in.
• de.hunsicker.jalopy.printer: Provides classes and interfaces for handling the AST output.
• de.hunsicker.util.concurrent: Contains miscellaneous utility and helper classes.
• de.hunsicker.util: Contains miscellaneous utility and helper classes.
• de.hunsicker.io: Contains I/O related stuff.
• de.hunsicker.swing.util: Contains GUI related stuff.
• de.hunsicker.swing: Contains GUI related stuff.
• de.hunsicker.jalopy.plugin.ant
• de.hunsicker.jalopy.plugin.console
• de.hunsicker.jalopy.plugin.eclipse.prefs
• de.hunsicker.jalopy.plugin.eclipse
• de.hunsicker.jalopy.plugin.jbuilder
• de.hunsicker.jalopy.plugin.jdeveloper.message
• de.hunsicker.jalopy.plugin.jdeveloper.swing

Classes:

• SwingWorker: An abstract class that you subclass to perform GUI-related work in a dedicated thread. This class was adapted from the SwingWorker written by Hans Muller and presented in "Using a Swing Worker Thread" in the Swing Connection - http://java.sun.com/products/jfc/tsc/articles/threads/threads2.html A closely related version of this class is described in "The Last Word in Swing Threads" in the Swing Connection - http://java.sun.com/products/jfc/tsc/articles/threads/threads3.html This SwingWorker is a ThreadFactoryUser and implements Runnable. The default thread factory creates low-priority worker threads. ...
• TreeWalker: Helper class to make implementing tree walkers easy. To implement a class that walks over all nodes simply dereive from TreeWalker and implement the callback method visit(de.hunsicker.antlr.collections.AST) 55 . class MyWalker extends TreeWalker { // called for every node public void visit(AST node) { System.out.println("node visited: " + node); } } If you want to control which nodes will be actually visited, overwrite walkNode(de.hunsicker.antlr.collections.AST) 55 too. // visits only IMPORT nodes and quits after the last IMPORT node found protected void walkNode(AST node) { switch (node.getType()) ...
• Jalopy: The bean-like interface to Jalopy. Sample Usage // create a new Jalopy instance with the currently active code convention settings Jalopy jalopy = new Jalopy(); File file = ...; // specify input and output target jalopy.setInput(file); jalopy.setOutput(file); // format and overwrite the given input file jalopy.format(); if (jalopy.getState() == Jalopy.State.OK) System.out.println(file + " successfully formatted"); else if (jalopy.getState() == Jalopy.State.WARN) System.out.println(file + " formatted with warnings"); else if (jalopy.getState() == Jalopy.State.ERROR) System.out.println(file + " could ...
• FutureResult: A class maintaining a single reference variable serving as the result of an operation. The result cannot be accessed until it has been set. Sample Usage class ImageRenderer { Image render(byte[] raw); } class App { Executor executor = ... ImageRenderer renderer = ... void display(byte[] rawimage) { try { FutureResult futureImage = new FutureResult(); Runnable command = futureImage.setter(new Callable() { public Object call() { return renderer.render(rawImage); } }); executor.execute(command); drawBorders(); // do other things while executing drawCaption(); drawImage((Image)(futureImage.get())); ...
• JavadocLexer: Token lexer for the Javadoc parser. This lexer has limited build-in error recovery which relies on the generated token types mapping table ( JavadocTokenTypes.txt ). Therefore it is a necessity to copy this file after every build into the directory where the classfile comes to reside. I strongly encourage you to automate this process as part of your Ant build script or whatever build tool you use. Sample Usage: // an input source Reader in = new BufferedReader(new FileReader(new File(argv[0]))); // create a lexer Lexer lexer = new JavadocLexer(); // set up the lexer to read from the input source ...
• ConventionKeys: Provides the valid keys for accessing the values in a code convention. Use this class in conjunction with ConventionDefaults to access the convention settings: Convention settings = Convention .getInstance(); int numThreads = settings.getInt( ConventionKeys .THREAD_COUNT, ConventionDefaults .THREAD_COUNT));
• ConventionDefaults: Holds the default code convention values (Sun Java Coding Style). Use this class in conjunction with ConventionKeys to access the convention settings: Convention settings = Convention .getInstance(); int numThreads = settings.getInt( ConventionKeys .THREAD_COUNT, ConventionDefaults .THREAD_COUNT));
• Convention: Represents a code convention: the settings that describe the desired coding style for Java source files. To ensure type-safety, valid key access, two accompanying classes are provided: Convention settings = Convention .getInstance(); int numThreads = settings.getInt( ConventionKeys .THREAD_COUNT, ConventionDefaults .THREAD_COUNT));
• ProgressPanel: A component that can be used to display progress information to the user. The panel displays the number of errors, warnings and processed files, along with a short text message and an optional progress bar. +---------------------------------------------------------------+ | Warnings: 2 Errors: 0 Files: 10 | | | | Processing ./src/java/de/hunsicker/jalopy/JalopyShell.java | | | | |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX | | +---------------------------------------------------------------+ The panel reflects the state of all logger channels as it increases its counters as warnings or errors ...
• TimedCallable: TimedCallable runs a Callable function for a given length of time. The function is run in its own thread. If the function completes in time, its result is returned; otherwise the thread is interrupted and an InterruptedException is thrown. Note: TimedCallable will always return within the given time limit (modulo timer inaccuracies), but whether or not the worker thread stops in a timely fashion depends on the interrupt handling in the Callable function's implementation. This class was taken from the util.concurrent package written by Doug Lea. See http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html ...
• SwitchPrinter: Printer for switch selection statements [ LITERAL_switch ]. switch ( integral-selector ) { case integral-value1 : statement // ... break; case integral-value2 : statement // ... break; case integral-value3 : statement // ... break; // ... default: statement } which translates to: LITERAL_switch + -- EXPR + ... + -- LCURLY + -- CASE_GROUP + -- LITERAL_case + -- EXPR + -- ... + -- SLIST + -- ... + -- CASE_GROUP + -- CASE_GROUP ... + -- RCURLY
• JavadocParser: Parser for Javadoc comments. Sample Usage: // an input source Reader in = new BufferedReader(new FileReader(new File(argv[0]))); // create a lexer Lexer lexer = new JavadocLexer(); // set up the lexer to read from the input source lexer.setInputBuffer(in); // get the corresponding parser Parser parser = lexer.getParser(); // and start the parsing process parser.parse(); This is an ANTLR automated generated file. DO NOT EDIT but rather change the associated grammar ( java.doc.g ) and rebuild.
• EmptyButtonGroup: Extends the standard button group to allow empty groups. Again creating a set of buttons with the same EmptyButtonGroup object means that turning 'on' one of those buttons turns 'off' all other buttons in the group. The difference between EmptyButtonGroup and ButtonGroup lies in the fact that the currently selected button can be deselected which results - in an empty group. Note that the original documentation for ButtonGroup (as of JDK 1.3) is wrong in that the initial state of the group does depend on the state of the added buttons (They claim 'Initially, all buttons in the group are unselected') ...
• Callable: Interface for runnable actions that bear results and/or throw Exceptions. This interface is designed to provide a common protocol for result-bearing actions that can be run independently in threads, in which case they are ordinarily used as the bases of Runnables that set FutureResults This class was taken from the util.concurrent package written by Doug Lea. See http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html for an introduction to this package.
• JavaLexer: Token lexer for the Java parser. Heavily based on the public domain grammar file written by Terence Parr et al. See http://www.antlr.org/resources.html for more info. Note that this parser relies on a patched version of ANTLR 2.7.2. It currently won't work with any other version. This is an ANTLR automated generated file. DO NOT EDIT but rather change the associated grammar ( java.g ) and rebuild.
• TimeoutException: Thrown by synchronization classes that report timeouts via exceptions. The exception is treated as a form (subclass) of InterruptedException. This both simplifies handling, and conceptually reflects the fact that timed-out operations are artificially interrupted by timers. This class was taken from the util.concurrent package written by Doug Lea. See http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html for an introduction to this package.
• ThreadFactory: Interface describing any class that can generate new Thread objects. Using ThreadFactories removes hardwiring of calls to new Thread , enabling applications to use special thread subclasses, default prioritization settings, etc. This class was taken from the util.concurrent package written by Doug Lea. See http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html for an introduction to this package.
• History: History serves as a tracker for file modifications. The flush() 55 method may be used to synchronously force updates to the backing store. Normal termination of the Java Virtual Machine will not result in the loss of pending updates - an explicit flushing is not required upon termination to ensure that pending updates are made persistent. This class is thread-safe.
• ThreadFactoryUser: Base class for Executors and related classes that rely on thread factories. Generally intended to be used as a mixin-style abstract class, but can also be used stand-alone. This class was taken from the util.concurrent package written by Doug Lea. See http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html for an introduction to this package.
• JavaParser: Parser for the Sun Java language. Heavily based on the public domain grammar written by Terence Parr et al. See http://www.antlr.org/resources.html for more info. This is an ANTLR automated generated file. DO NOT EDIT but rather change the associated grammar ( java.g ) and rebuild.
• SyntaxDocument: The interface a document must implement to be colorizable by the SyntaxEditorKit . It defines two methods, one that returns the TokenMarker that will split a line into a list of tokens, and a method that returns a color array that maps identification tags returned by the token marker into Color objects. The possible token identifiers are defined as static fields in the Token class.
• SettingsDialog: The Jalopy settings dialog provides a graphical user interface to manage, display and interactively test and edit the available code convention and asorted configuration settings. The dialog can be used from other Java applications as usual, in which case it acts like any other JDialog (i.e. as a secondary window). But it may be also invoked directly from the command line, magically serving as the main application window.
• FlowControlPrinter: Printer for flow control statements ( LITERAL_break and LITERAL_continue . label1: outer-iteration { inner-iteration { // ... break ; // ... continue ; // ... continue label1; // ... break label1; } }
• TokenMarker: A token marker that splits lines of text into tokens. Each token carries a length field and an indentification tag that can be mapped to a color for painting that token. For performance reasons, the linked list of tokens is reused after each line is tokenized. Therefore, the return value of markTokens should only be used for immediate painting. Notably, it cannot be cached.
• DeclarationType: Represents a method type to distinguish between ordinary method names and those which adhere to the Java Bean naming conventions. The default order for comparing is: ordinary Java method names, mutator, accessor/tester. This can be changed via setOrder(java.lang.String) 55 .

Home | Contact Us | Privacy Policy | Terms of Service