All Classes and Interfaces
Class
Description
The class implements the //#abort directive handler
The class is the abstract parent for all classes process preprocessor
directives
The abstract class is the base for each function handler in the preprocessor
The class is the base for all operator handlers
The class is parent for converting classes.
The class implements the //#action directive handler
The enumeration contains flags after directive processing behavior
Allow spaces between comment and directive.
Error if detected attempt to dispose already disposed object.
PathMatcher implementation for Ant-style path patterns.Tests whether or not a string matches against a pattern via a
Pattern.The default
Comparator implementation returned by
AntPathMatcher.getPatternComparator(String).Value class that holds information about the pattern, e.g.
A simple cache for patterns that depend on the configured path separator.
Set of auxiliary methods to process arrays.
Set of auxiliary methods for assertion.
The class implements the //#break directive handler
The Class allows to save stack trace history (it is possible to keep it in packed format) and restore it to text representation for request.
The handler to process the key signals that the preprocessor must clear the
destination directory before preprocessing
Miscellaneous collection utility methods.
Iterator wrapping an Enumeration.
The interface describes a command line key handler.
The class implements the //#// directive handler
the Handler processes command to disable overriding of existing file if content the same.
Complexity constants.
It allows to mark either field or parameter by some expression.
The class implements the //#continue directive handler
The handler keep file attributes of copied or generated files.
Auxiliary tool to defer some actions and process them in some point in future.
Class wrapping executeDeferred method and stack depth for action.
The class implements the //#define directive handler
The class implements the //#definel directive handler
The handler for the output directory command line key
Shows that behavior of the entity is determined.
The enumeration contains possible argument types are being used by directives
Auxiliary interface describing disposable object.
Template providing disposable functionality.
The class implements //#assert directive handler
The class implements the //#else directive handler
The class implements the //#end directive
The class implements the //#endif directive handler
The class allows to get access to environment variables from preprocessor
expression, the variables have the "env." prefix and all them are String type
All environment variables are allowed for reading and disallowing for writing
The class implements //#error directive handler
The handler for the excluded extension list (with comma)
The Handler of subfolder names to be excluded from preprocessing, allows ANT pattern matching.
The class implements the //#excludeif directive handler
The class implements the //#exit directive handler
The class implements the //#exitif directive handler
Marks item as experimental one.
The main class to calculate expressions
The interface describes an object which can be used during expression
calculations
This class is a parser allows to parse an expression and make a tree as the output
The enumeration describes inside states of the parses
The enumeration describes some special items which can be met in the expression
The class describes an object contains an expression tree
The class describes a wrapper around an expression item to be saved into an expression tree
The handler for the preprocessing file extension list (with comma)
The class is one from the main classes in the preprocessor because it describes a preprocessing file and contains business logic for the process
The class implements a file data storage where an exception can store a
snapshot of the current preprocessing file data
The class implements the //#flush directive handler
The class implements the abs function handler
The Function loads bin file and encodes it into string.
The class implements the user defined function handler (a function which name
starts with $)
The Function makes preprocessing of a file and return result as a string value.
The class implements the IS function handler
The class implements the ISSUBSTR function handler
The class implements the round function handler
The class implements the str2csv function handler
The class implements escape function handler to escape strings to be used in Go.
The class implements the str2int function handler
The class implements escape function handler to escape strings to be used in java.
The class implements the str2js function handler
The class implements the str2json function handler
The class implements the str2web function handler
The class implements the str2xml function handler
The class implements the STRLEN function handler
The class implements the TRIMLINES function handler
The class implements the xml_attr function
The class implements the xml_get function handler
The class implements the xml_list function handler
The class implements the xml_name function handler
The class implements the xml_open function handler
The class implements the xml_getroot function handler
The class implements the xml_elementsnumber function
The class implements the xml_getelementtext function handler
The class implements the xml_xpathelement function handler
The class implements the xml_xpathlist function handler
Auxiliary methods to get values.
The class implements the //#global directive handler
The class implements the //#_else directive handler
The class implements the //#_endif directive handler
The class implements the //#_if directive handler
The handler for '@' prefixed files in the command string
The handler for global variables, it adds met global variables into the
inside storage
The handler processes a help command from the command string
Display help information on jcp.
Call
Call
mvn jcp:help -Ddetail=true -Dgoal=<goal-name> to display parameter details.The class implements short synonym for the //#ifdefined directive
The class implements the //#ifdefined directive handler
The class implements the //#if directive handler
The class implements the //#ifndef directive handler
Allows to define some implementation note about marked entity.
To set the input text character encoding
The class implements the //#include directive handler
Auxiliary methods for IO operations.
A remover allows to cut off all Java like comments from a reader and write the result into a writer
The main class implements the Java Comment Preprocessor, it has the main
method and can be started from a command string
The class implements the special variable processor interface and allows to get access to inside JCP variables Inside JCP variables have the "jcp." prefix
Allows to keep information about point where instance of the class was created.
The handler processing the flag tells the preprocessor to be try to keep
non-executing lines of code as commented ones
Shows that marked entity is lazy inited one
Allows provide some link in text form for an entity.
The class implements the //#local directive handler
The class imports some properties from the maven which can be accessible from preprocessed sources as global variables
Shows that marked entity can contain null among its inside values.
Allows to mark executable entity by its memory complexity description.
Interface for a meta error processor catching errors detected by the common module methods.
Service containing all error listeners for the common module methods and providing their notifications.
The class implements //#msg directive handler
Shows that an array or a collection can't contain null as its value.
Signal that marked entity needs refactoring.
The class implements the //#noautoflush directive handler
It's a special auxiliary class to save XML node data in a preprocessor
storage
Shows that behavior of the entity is non-determined.
Miscellaneous object utility methods.
Allows mark methods as impacting on something without any chance for rollback.
The class implements the ADD operator handler
The class implements the AND operator handler
The class implements the DIV operator handler
The class implements the EQU operator handler
The class implements the GREAT operator handler
The class implements the GREATEQU operator handler
The class implements the LESS operator handler
The class implements the LESSEQU operator handler
The class implements the MOD operator handler
The class implements the MOD operator handler
The class implements the NOT operator handler
The class implements the NOTEQU operator handler
The class implements the OR operator handler
The class implements the SUB operator handler
The class implements the XOR operator handler
To set the output text character encoding
The class implements the //#outdir directive handler
The class implements the //#- directive handler
The class implements the //#+ directive handler
The class implements the //#outname directive handler
Strategy interface for
String-based path matching.The class implements the //#postfix[+|-] directive handler
The class implements the //#prefix[+|-] directive handler
The enumeration contains flags describe inside special preprocessor states
The class describes a preprocessor state also it contains inside buffers and save data on disk
The Mojo allows to delete preprocessed folders.
The preprocessor context class is a main class which contains all options of the preprocessor and allows to work with variables in expressions
The exception allows to save some useful data about preprocessing files like the current include stack and the error string index
The interface describes an extension which can be connected to a preprocessor
and to be notified about some calls and actions
The interface describes a logger to be used by a preprocessor during its work
The Mojo makes preprocessing of defined or project root source folders and place result in defined or predefined folder, also it can replace the source folder for a maven
project to use the preprocessed sources.
It is an auxiliary class contains some useful methods
The class implements an ANT task to allow calls for preprocessing from ANT build scripts.
Inside class describes a "cfgfile" item, it has the only attribute "file", the attribute must be defined
Inside class describes a "global" item, it describes a global variable which will be added into the preprocessor context It has attributes "name" and "value", be careful in
the value attribute usage because you have to use """ instead of \" symbol inside string values
The Mojo is auxiliary wrapper over the standard preprocess mojo to automate providing of TRUE as the 'useTestSources' flag.
Preserve indent when removing line-prefixes "//$" and "//$$"
The handler processing the flag to clear all sources in the destination
directory from inside comments
The class implements a resetable char printer
Allows mark method result if the method returns link to the original object and you want notify a method user that it should be changed carefully.
Marks entity as risky one.
The handler processing the key to set the source directory
The interface describes a special variable processor which will be called for
variables met by a preprocessor in expressions
Miscellaneous
String utility methods.Set of auxiliary string functions.
An Easy logger which just output log messages into the system output streams
The class contains text data of a file and the string position index for the file
Auxiliary methods for thread processing.
Allows to describe a runtime exception thrown by method.
It allows to describe set of runtime exceptions thrown by method.
Allows to mark executable entity by its time complexity description.
Allows to detect violations of execution time for code blocks or just measure time for them.
Interface for any object to be informed about time alerts.
Data container for time watching action.
The Error shows that some time bounds violation detected during execution.
Allows to mark entities for future works.
The class implements the //#undef directive handler
Thrown if detected unexpected exception during processing.
The handler processing the flag tells the preprocessor to be try to keep
non-executing lines of code as commented ones
Validator to check an object.
The class describes an expression value i.e.
The enumeration contains all allowed types for expression values and their
signatures
The class describes an expression variable
The handler processing the flag that the preprocessor to be verbose in its
messages and information
Allows to mark entities by some warning messages.
The class implements //#warning directive handler
Allows to define computational weight of an entity, in fuzzy human-subjective relative units.
Contains allowed units for execution weight.
The class implements the //#while directive handler