All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary Annotation Types Summary
| Class |
Description |
| AbortDirectiveHandler |
The class implements the //#abort directive handler
|
| AbstractDirectiveHandler |
The class is the abstract parent for all classes process preprocessor
directives
|
| AbstractFunction |
The abstract class is the base for each function handler in the preprocessor
|
| AbstractOperator |
The class is the base for all operator handlers
|
| AbstractStrConverter |
The class is parent for converting classes.
|
| AbstractXMLFunction |
|
| ActionDirectiveHandler |
The class implements the //#action directive handler
|
| AfterDirectiveProcessingBehaviour |
The enumeration contains flags after directive processing behavior
|
| AllowWhitespaceDirectiveHandler |
Allow spaces between comment and directive.
|
| AlreadyDisposedError |
Error if detected attempt to dispose already disposed object.
|
| AntPathMatcher |
PathMatcher implementation for Ant-style path patterns. |
| AntPathMatcher.AntPathStringMatcher |
Tests whether or not a string matches against a pattern via a
Pattern.
|
| AntPathMatcher.AntPatternComparator |
|
| AntPathMatcher.AntPatternComparator.PatternInfo |
Value class that holds information about the pattern, e.g.
|
| AntPathMatcher.PathSeparatorPatternCache |
A simple cache for patterns that depend on the configured path separator.
|
| ArrayUtils |
Set of auxiliary methods to process arrays.
|
| Assertions |
Set of auxiliary methods for assertion.
|
| BreakDirectiveHandler |
The class implements the //#break directive handler
|
| CallTrace |
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.
|
| CareForLastNextLineCharHandler |
|
| ClearDstDirectoryHandler |
The handler to process the key signals that the preprocessor must clear the
destination directory before preprocessing
|
| CollectionUtils |
Miscellaneous collection utility methods.
|
| CollectionUtils.EnumerationIterator<E> |
Iterator wrapping an Enumeration.
|
| CommandLineHandler |
The interface describes a command line key handler.
|
| CommentNextLineDirectiveHandler |
The class implements the //#// directive handler
|
| CompareDestinationContentHandler |
the Handler processes command to disable overriding of existing file if content the same.
|
| Complexity |
Complexity constants.
|
| Constraint |
It allows to mark either field or parameter by some expression.
|
| ContinueDirectiveHandler |
The class implements the //#continue directive handler
|
| CopyFileAttributesHandler |
The handler keep file attributes of copied or generated files.
|
| Deferrers |
Auxiliary tool to defer some actions and process them in some point in future.
|
| Deferrers.Deferred |
Class wrapping executeDeferred method and stack depth for action.
|
| DefineDirectiveHandler |
The class implements the //#define directive handler
|
| DefinelDirectiveHandler |
The class implements the //#definel directive handler
|
| DestinationDirectoryHandler |
The handler for the output directory command line key
|
| Determined |
|
| DirectiveArgumentType |
The enumeration contains possible argument types are being used by directives
|
| Disposable |
Auxiliary interface describing disposable object.
|
| DisposableTemplate |
Template providing disposable functionality.
|
| EchoDirectiveHandler |
The class implements //#assert directive handler
|
| ElseDirectiveHandler |
The class implements the //#else directive handler
|
| EndDirectiveHandler |
The class implements the //#end directive
|
| EndIfDirectiveHandler |
The class implements the //#endif directive handler
|
| EnvironmentVariableProcessor |
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
|
| ErrorDirectiveHandler |
The class implements //#error directive handler
|
| ExcludedFileExtensionsHandler |
The handler for the excluded extension list (with comma)
|
| ExcludeFoldersHandler |
The Handler of subfolder names to be excluded from preprocessing, allows ANT pattern matching.
|
| ExcludeIfDirectiveHandler |
The class implements the //#excludeif directive handler
|
| ExitDirectiveHandler |
The class implements the //#exit directive handler
|
| ExitIfDirectiveHandler |
The class implements the //#exitif directive handler
|
| Experimental |
Marks item as experimental one.
|
| Expression |
The main class to calculate expressions
|
| ExpressionItem |
The interface describes an object which can be used during expression
calculations
|
| ExpressionItemPriority |
|
| ExpressionItemType |
|
| ExpressionParser |
This class is a parser allows to parse an expression and make a tree as the output
|
| ExpressionParser.ParserState |
The enumeration describes inside states of the parses
|
| ExpressionParser.SpecialItem |
The enumeration describes some special items which can be met in the expression
|
| ExpressionTree |
The class describes an object contains an expression tree
|
| ExpressionTreeElement |
The class describes a wrapper around an expression item to be saved into an expression tree
|
| FileExtensionsHandler |
The handler for the preprocessing file extension list (with comma)
|
| FileInfoContainer |
The class is one from the main classes in the preprocessor because it describes a preprocessing file and contains business logic for the process
|
| FilePositionInfo |
The class implements a file data storage where an exception can store a
snapshot of the current preprocessing file data
|
| FlushDirectiveHandler |
The class implements the //#flush directive handler
|
| FunctionABS |
The class implements the abs function handler
|
| FunctionBINFILE |
The Function loads bin file and encodes it into string.
|
| FunctionBINFILE.Type |
|
| FunctionDefinedByUser |
The class implements the user defined function handler (a function which name
starts with $)
|
| FunctionEVALFILE |
The Function makes preprocessing of a file and return result as a string value.
|
| FunctionIS |
The class implements the IS function handler
|
| FunctionISSUBSTR |
The class implements the ISSUBSTR function handler
|
| FunctionROUND |
The class implements the round function handler
|
| FunctionSTR2CSV |
The class implements the str2csv function handler
|
| FunctionSTR2GO |
The class implements escape function handler to escape strings to be used in Go.
|
| FunctionSTR2INT |
The class implements the str2int function handler
|
| FunctionSTR2JAVA |
The class implements escape function handler to escape strings to be used in java.
|
| FunctionSTR2JS |
The class implements the str2js function handler
|
| FunctionSTR2JSON |
The class implements the str2json function handler
|
| FunctionSTR2WEB |
The class implements the str2web function handler
|
| FunctionSTR2XML |
The class implements the str2xml function handler
|
| FunctionSTRLEN |
The class implements the STRLEN function handler
|
| FunctionTRIMLINES |
The class implements the TRIMLINES function handler
|
| FunctionXML_ATTR |
The class implements the xml_attr function
|
| FunctionXML_GET |
The class implements the xml_get function handler
|
| FunctionXML_LIST |
The class implements the xml_list function handler
|
| FunctionXML_NAME |
The class implements the xml_name function handler
|
| FunctionXML_OPEN |
The class implements the xml_open function handler
|
| FunctionXML_ROOT |
The class implements the xml_getroot function handler
|
| FunctionXML_SIZE |
The class implements the xml_elementsnumber function
|
| FunctionXML_TEXT |
The class implements the xml_getelementtext function handler
|
| FunctionXML_XELEMENT |
The class implements the xml_xpathelement function handler
|
| FunctionXML_XLIST |
The class implements the xml_xpathlist function handler
|
| GetUtils |
Auxiliary methods to get values.
|
| GlobalDirectiveHandler |
The class implements the //#global directive handler
|
| GlobalElseDirectiveHandler |
The class implements the //#_else directive handler
|
| GlobalEndIfDirectiveHandler |
The class implements the //#_endif directive handler
|
| GlobalIfDirectiveHandler |
The class implements the //#_if directive handler
|
| GlobalVariableDefiningFileHandler |
The handler for '@' prefixed files in the command string
|
| GlobalVariableHandler |
The handler for global variables, it adds met global variables into the
inside storage
|
| HelpHandler |
The handler processes a help command from the command string
|
| IfDefDirectiveHandler |
The class implements short synonym for the //#ifdefined directive
|
| IfDefinedDirectiveHandler |
The class implements the //#ifdefined directive handler
|
| IfDirectiveHandler |
The class implements the //#if directive handler
|
| IfNDefDirectiveHandler |
The class implements the //#ifndef directive handler
|
| Immutable |
|
| ImplementationNote |
Allows to define some implementation note about marked entity.
|
| InCharsetHandler |
To set the input text character encoding
|
| IncludeDirectiveHandler |
The class implements the //#include directive handler
|
| InfoHelper |
|
| InvalidObjectError |
|
| IOUtils |
Auxiliary methods for IO operations.
|
| JavaCommentsRemover |
A remover allows to cut off all Java like comments from a reader and write the result into a writer
|
| JCPreprocessor |
The main class implements the Java Comment Preprocessor, it has the main
method and can be started from a command string
|
| JCPreprocessor.PreprocessingStatistics |
|
| JCPSpecialVariableProcessor |
The class implements the special variable processor interface and allows to get access to inside JCP variables Inside JCP variables have the "jcp." prefix
|
| JCPSpecialVariableProcessor.NameReferencePair |
|
| KeepCreationPointTemplate |
Allows to keep information about point where instance of the class was created.
|
| KeepLineHandler |
The handler processing the flag tells the preprocessor to be try to keep
non-executing lines of code as commented ones
|
| LazyInited |
|
| Link |
Allows provide some link in text form for an entity.
|
| LocalDirectiveHandler |
The class implements the //#local directive handler
|
| MavenPropertiesImporter |
The class imports some properties from the maven which can be accessible from preprocessed sources as global variables
|
| MayContainNull |
Shows that marked entity can contain null among its inside values.
|
| MemoryComplexity |
Allows to mark executable entity by its memory complexity description.
|
| MetaErrorListener |
Interface for a meta error processor catching errors detected by the common module methods.
|
| MetaErrorListeners |
Service containing all error listeners for the common module methods and providing their notifications.
|
| MsgDirectiveHandler |
The class implements //#msg directive handler
|
| MustNotContainNull |
Shows that an array or a collection can't contain null as its value.
|
| NeedsRefactoring |
Signal that marked entity needs refactoring.
|
| NoAutoFlushHandler |
The class implements the //#noautoflush directive handler
|
| NodeContainer |
It's a special auxiliary class to save XML node data in a preprocessor
storage
|
| NonDetermined |
|
| Nonnull |
|
| Nullable |
|
| ObjectUtils |
Miscellaneous object utility methods.
|
| OneWayChange |
Allows mark methods as impacting on something without any chance for rollback.
|
| OperatorADD |
The class implements the ADD operator handler
|
| OperatorAND |
The class implements the AND operator handler
|
| OperatorDIV |
The class implements the DIV operator handler
|
| OperatorEQU |
The class implements the EQU operator handler
|
| OperatorGREAT |
The class implements the GREAT operator handler
|
| OperatorGREATEQU |
The class implements the GREATEQU operator handler
|
| OperatorLESS |
The class implements the LESS operator handler
|
| OperatorLESSEQU |
The class implements the LESSEQU operator handler
|
| OperatorMOD |
The class implements the MOD operator handler
|
| OperatorMUL |
The class implements the MOD operator handler
|
| OperatorNOT |
The class implements the NOT operator handler
|
| OperatorNOTEQU |
The class implements the NOTEQU operator handler
|
| OperatorOR |
The class implements the OR operator handler
|
| OperatorSUB |
The class implements the SUB operator handler
|
| OperatorXOR |
The class implements the XOR operator handler
|
| OutCharsetHandler |
To set the output text character encoding
|
| OutDirDirectiveHandler |
The class implements the //#outdir directive handler
|
| OutDisabledDirectiveHandler |
The class implements the //#- directive handler
|
| OutEnabledDirectiveHandler |
The class implements the //#+ directive handler
|
| OutNameDirectiveHandler |
The class implements the //#outname directive handler
|
| PathMatcher |
Strategy interface for String-based path matching.
|
| PostfixDirectiveHandler |
The class implements the //#postfix[+|-] directive handler
|
| PrefixDirectiveHandler |
The class implements the //#prefix[+|-] directive handler
|
| PreprocessingFlag |
The enumeration contains flags describe inside special preprocessor states
|
| PreprocessingState |
The class describes a preprocessor state also it contains inside buffers and save data on disk
|
| PreprocessingState.ExcludeIfInfo |
|
| PreprocessingState.PrinterType |
|
| PreprocessorClearMojo |
The Mojo allows to delete preprocessed folders.
|
| PreprocessorContext |
The preprocessor context class is a main class which contains all options of the preprocessor and allows to work with variables in expressions
|
| PreprocessorException |
The exception allows to save some useful data about preprocessing files like the current include stack and the error string index
|
| PreprocessorExtension |
The interface describes an extension which can be connected to a preprocessor
and to be notified about some calls and actions
|
| PreprocessorLogger |
The interface describes a logger to be used by a preprocessor during its work
|
| PreprocessorMojo |
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.
|
| PreprocessorUtils |
It is an auxiliary class contains some useful methods
|
| PreprocessTask |
The class implements an ANT task to allow calls for preprocessing from ANT build scripts.
|
| PreprocessTask.CfgFile |
Inside class describes a "cfgfile" item, it has the only attribute "file", the attribute must be defined
|
| PreprocessTask.Global |
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
|
| PreprocessTestsMojo |
The Mojo is auxiliary wrapper over the standard preprocess mojo to automate providing of TRUE as the 'useTestSources' flag.
|
| PreserveIndentDirectiveHandler |
Preserve indent when removing line-prefixes "//$" and "//$$"
|
| RemoveCommentsHandler |
The handler processing the flag to clear all sources in the destination
directory from inside comments
|
| ResetablePrinter |
The class implements a resetable char printer
|
| ReturnsOriginal |
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.
|
| Risky |
Marks entity as risky one.
|
| SourceDirectoryHandler |
The handler processing the key to set the source directory
|
| SpecialVariableProcessor |
The interface describes a special variable processor which will be called for
variables met by a preprocessor in expressions
|
| StringUtils |
Miscellaneous String utility methods.
|
| StrUtils |
Set of auxiliary string functions.
|
| SystemOutLogger |
An Easy logger which just output log messages into the system output streams
|
| TextFileDataContainer |
The class contains text data of a file and the string position index for the file
|
| ThreadSafe |
|
| ThreadUtils |
Auxiliary methods for thread processing.
|
| ThrowsRuntimeException |
Allows to describe a runtime exception thrown by method.
|
| ThrowsRuntimeExceptions |
It allows to describe set of runtime exceptions thrown by method.
|
| TimeComplexity |
Allows to mark executable entity by its time complexity description.
|
| TimeGuard |
Allows to detect violations of execution time for code blocks or just measure time for them.
|
| TimeGuard.TimeAlertListener |
Interface for any object to be informed about time alerts.
|
| TimeGuard.TimeData |
Data container for time watching action.
|
| TimeViolationError |
The Error shows that some time bounds violation detected during execution.
|
| ToDo |
Allows to mark entities for future works.
|
| UndefDirectiveHandler |
The class implements the //#undef directive handler
|
| UnexpectedProcessingError |
Thrown if detected unexpected exception during processing.
|
| UnknownAsFalseHandler |
The handler processing the flag tells the preprocessor to be try to keep
non-executing lines of code as commented ones
|
| Validator<T> |
Validator to check an object.
|
| Value |
The class describes an expression value i.e.
|
| ValueType |
The enumeration contains all allowed types for expression values and their
signatures
|
| Variable |
The class describes an expression variable
|
| VerboseHandler |
The handler processing the flag that the preprocessor to be verbose in its
messages and information
|
| Warning |
Allows to mark entities by some warning messages.
|
| WarningDirectiveHandler |
The class implements //#warning directive handler
|
| Weight |
Allows to define computational weight of an entity, in fuzzy human-subjective relative units.
|
| Weight.Unit |
Contains allowed units for execution weight.
|
| WhileDirectiveHandler |
The class implements the //#while directive handler
|