Package com.igormaznitsa.jcp.context

Class PreprocessorContext

  • public final class PreprocessorContext
extends java.lang.Object
    The preprocessor context class is a main class which contains all options of the preprocessor and allows to work with variables in expressions

    • Field Detail

      • DEFAULT_SOURCE_DIRECTORY

        public static final java.lang.String DEFAULT_SOURCE_DIRECTORY

      • DEFAULT_DEST_DIRECTORY

        public static final java.lang.String DEFAULT_DEST_DIRECTORY

      • DEFAULT_PROCESSING_EXTENSIONS

        public static final java.lang.String DEFAULT_PROCESSING_EXTENSIONS
        See Also:
        Constant Field Values

      • DEFAULT_EXCLUDED_EXTENSIONS

        public static final java.lang.String DEFAULT_EXCLUDED_EXTENSIONS
        See Also:
        Constant Field Values

      • verbose

        private boolean verbose

      • removeComments

        private boolean removeComments

      • clearDestinationDirectoryBefore

        private boolean clearDestinationDirectoryBefore

      • fileOutputDisabled

        private boolean fileOutputDisabled

      • keepNonExecutingLines

        private boolean keepNonExecutingLines

      • careForLastNextLine

        private boolean careForLastNextLine

      • compareDestination

        private boolean compareDestination

      • allowWhitespace

        private boolean allowWhitespace

      • preserveIndent

        private boolean preserveIndent

      • copyFileAttributes

        private boolean copyFileAttributes

      • unknownVariableAsFalse

        private boolean unknownVariableAsFalse

      • sourceDirectories

        private java.lang.String sourceDirectories

      • destinationDirectory

        private java.lang.String destinationDirectory

      • destinationDirectoryFile

        private java.io.File destinationDirectoryFile

      • sourceDirectoryFiles

        private java.io.File[] sourceDirectoryFiles

      • processingFileExtensions

        private java.util.Set<java.lang.String> processingFileExtensions

      • excludedFileExtensions

        private java.util.Set<java.lang.String> excludedFileExtensions

      • inCharacterEncoding

        private java.lang.String inCharacterEncoding

      • outCharacterEncoding

        private java.lang.String outCharacterEncoding

      • globalVarTable

        private final java.util.Map<java.lang.String,​Value> globalVarTable

      • localVarTable

        private final java.util.Map<java.lang.String,​Value> localVarTable

      • mapVariableNameToSpecialVarProcessor

        private final java.util.Map<java.lang.String,​SpecialVariableProcessor> mapVariableNameToSpecialVarProcessor

      • sharedResources

        private final java.util.Map<java.lang.String,​java.lang.Object> sharedResources

      • configFiles

        private final java.util.List<java.io.File> configFiles

      • cloned

        private final boolean cloned

      • excludedFolderPatterns

        private java.lang.String[] excludedFolderPatterns

    • Constructor Detail

      • PreprocessorContext

        public PreprocessorContext()
        The constructor

      • PreprocessorContext

        public PreprocessorContext​(PreprocessorContext context)
        Make clone of a preprocessor context but without cloning state.
        Parameters:
        context - the context to be cloned, must not be null.

    • Method Detail

      • setExcludedFolderPatterns

        public void setExcludedFolderPatterns​(@MustNotContainNull
                                      java.lang.String... patterns)
        Set patterns for excluded folders.
        Parameters:
        patterns - array contains Ant path patterns

      • getExcludedFolderPatterns

        @MustNotContainNull
public java.lang.String[] getExcludedFolderPatterns()
        Get patterns for excluded folders.
        Returns:
        array of patterns in Ant pattern format

      • setCareForLastNextLine

        public void setCareForLastNextLine​(boolean flag)
        Set the flag to care to be precise in processing the last file next line char
        Parameters:
        flag - true to turn on the mode, false to turn off

      • isCareForLastNextLine

        public boolean isCareForLastNextLine()

      • isCloned

        public boolean isCloned()
        Check that the preprocessor context is a clone of another context.
        Returns:
        true if the context is a clone, false otherwise

      • setPreprocessorLogger

        public void setPreprocessorLogger​(PreprocessorLogger logger)
        Set the logger to print information and error messages
        Parameters:
        logger - a logger to be used for output, it can be null

      • registerSpecialVariableProcessor

        public void registerSpecialVariableProcessor​(SpecialVariableProcessor processor)
        It allows to register a special variable processor which can process some special global variables
        Parameters:
        processor - a variable processor to be registered, it must not be null
        See Also:
        SpecialVariableProcessor

      • logInfo

        public void logInfo​(java.lang.String text)
        Print an information into the current log
        Parameters:
        text - a String to be printed into the information log, it can be null

      • logError

        public void logError​(java.lang.String text)
        Print an information about an error into the current log
        Parameters:
        text - a String to be printed into the error log, it can be null

      • logDebug

        public void logDebug​(java.lang.String text)
        Print some debug info into the current log
        Parameters:
        text - a String to be printed into the error log, it can be null
        Since:
        6.0.1

      • logWarning

        public void logWarning​(java.lang.String text)
        Print an information about a warning situation into the current log
        Parameters:
        text - a String to be printed into the warning log, it can be null

      • setRemoveComments

        public PreprocessorContext setRemoveComments​(boolean removingComments)
        Set the remove comments flag
        Parameters:
        removingComments - the flag to set, true if comments must be removed from the result files, otherwise else
        Returns:
        the preprocessor context instance

      • isRemoveComments

        public boolean isRemoveComments()
        It returns the flag shows that all comments must be removed from the result
        Returns:
        true if comments must be returned, otherwise false

      • setFileOutputDisabled

        public void setFileOutputDisabled​(boolean flag)
        It allows to disable all writing operations of the preprocessor
        Parameters:
        flag - true if preprocessor must not make any writing operations, otherwise false

      • isFileOutputDisabled

        public boolean isFileOutputDisabled()
        Check that writing operations is disabled
        Returns:
        true if writing operations disabled, otherwise false

      • setAllowWhitespace

        public void setAllowWhitespace​(boolean flag)
        Set flag to allow whitespace between directive and comment chars.
        Parameters:
        flag - true if whitespace allowed, false otherwise

      • isAllowWhitespace

        public boolean isAllowWhitespace()
        Get flag that whitespace allowed between directive and comment.
        Returns:
        true if whitespace allowed, false otherwise

      • setUnknownVariableAsFalse

        public void setUnknownVariableAsFalse​(boolean flag)
        Set flag to interpret unknown variable value as FALSE.
        Parameters:
        flag - true to turn on mode when unknown variable will be recognized as FALSE

      • isUnknownVariableAsFalse

        public boolean isUnknownVariableAsFalse()
        Get flag shows that unknown variable is recognized as FALSE.
        Returns:
        true if unknown variable must be recognized as FALSE.

      • setPreserveIndent

        public void setPreserveIndent​(boolean flag)
        Set flag to control whether prefixes "//$", "//$$" should replaced with equal length whitespace strings rather than just removed.
        Parameters:
        flag - true enables preserve-indent, false disables it

      • isPreserveIndent

        public boolean isPreserveIndent()
        Get flag indicating whether preserve-indent is enabled or disabled.
        Returns:
        true if preserve-indent is enabled, false otherwise

      • setSourceDirectories

        public PreprocessorContext setSourceDirectories​(java.lang.String directories)
        Set source directories
        Parameters:
        directories - semi separated list of source directories, must not be null
        Returns:
        this preprocessor context instance

      • setSharedResource

        public void setSharedResource​(java.lang.String name,
                              java.lang.Object obj)
        Set a shared source, it is an object saved into the inside map for a name
        Parameters:
        name - the name for the saved project, must not be null
        obj - the object to be saved in, must not be null

      • getSharedResource

        public java.lang.Object getSharedResource​(java.lang.String name)
        Get a shared source from inside map
        Parameters:
        name - the name of the needed object, it must not be null
        Returns:
        a cached object or null if it is not found

      • removeSharedResource

        public java.lang.Object removeSharedResource​(java.lang.String name)
        Remove a shared object from the inside map for its name
        Parameters:
        name - the object name, it must not be null
        Returns:
        removing object or null if it is not found

      • getSourceDirectories

        public java.lang.String getSourceDirectories()
        Get the source directories as semi separated string
        Returns:
        the current source directories semi separated list

      • getSourceDirectoryAsFiles

        @MustNotContainNull
public java.io.File[] getSourceDirectoryAsFiles()
        Get the current source directories as a file array
        Returns:
        the current source directories as a file array

      • getParsedSourceDirectoryAsFiles

        @MustNotContainNull
private java.io.File[] getParsedSourceDirectoryAsFiles()
        Inside auxiliary method to parse the source directories list into file array
        Returns:
        parsed file list, each file must exist and be a directory

      • setDestinationDirectory

        public PreprocessorContext setDestinationDirectory​(java.lang.String directory)
        Set a destination directory for result files
        Parameters:
        directory - a path to the directory as String, it must not be null
        Returns:
        this preprocessor context instance

      • getDestinationDirectoryAsFile

        public java.io.File getDestinationDirectoryAsFile()
        Get the current destination directory as a File object
        Returns:
        the current destination directory as an object

      • getDestinationDirectory

        public java.lang.String getDestinationDirectory()
        Get the string representation of the destination directory
        Returns:
        the current destination directory as a String

      • setProcessingFileExtensions

        public PreprocessorContext setProcessingFileExtensions​(java.lang.String extensions)
        Set file extensions of files to be preprocessed, it is a comma separated list
        Parameters:
        extensions - comma separated extensions list of file extensions to be preprocessed, must not be null
        Returns:
        this preprocessor context

      • getProcessingFileExtensions

        @MustNotContainNull
public java.lang.String[] getProcessingFileExtensions()
        Get file extensions of files to be preprocessed as a string array
        Returns:
        a string array of file extensions to be preprocessed

      • isFileAllowedToBeProcessed

        public final boolean isFileAllowedToBeProcessed​(java.io.File file)
        Check that a file is allowed to be preprocessed fo its extension
        Parameters:
        file - a file to be checked
        Returns:
        true if the file is allowed, false otherwise

      • isFileExcludedFromProcess

        public final boolean isFileExcludedFromProcess​(java.io.File file)
        Check that a file is excluded from preprocessing and coping actions
        Parameters:
        file - a file to be checked
        Returns:
        true if th file must be excluded, otherwise false

      • setExcludedFileExtensions

        public PreprocessorContext setExcludedFileExtensions​(java.lang.String extensions)
        Set comma separated list of file extensions to be excluded from preprocessing
        Parameters:
        extensions - a comma separated file extension list, it must not be null
        Returns:
        this preprocessor context

      • getExcludedFileExtensions

        @MustNotContainNull
public java.lang.String[] getExcludedFileExtensions()
        Get excluded file extension list as a string array
        Returns:
        a string array contains file extensions to be excluded from preprocessing act

      • setClearDestinationDirBefore

        public PreprocessorContext setClearDestinationDirBefore​(boolean flag)
        Set the flag to clear the destination directory before preprocessing
        Parameters:
        flag - true if the directory must be cleaned, otherwise false
        Returns:
        this preprocessor context

      • doesClearDestinationDirBefore

        public boolean doesClearDestinationDirBefore()
        Get the flag to clear the destination directory before preprocessing
        Returns:
        true if the directory must be cleaned, otherwise false

      • setLocalVariable

        public PreprocessorContext setLocalVariable​(java.lang.String name,
                                            Value value)
        Set a local variable value
        Parameters:
        name - the variable name, must not be null, remember that the name will be normalized and will be entirely in lower case
        value - the value for the variable, it must not be null
        Returns:
        this preprocessor context
        See Also:
        Value

      • removeLocalVariable

        public PreprocessorContext removeLocalVariable​(java.lang.String name)
        Remove a local variable value from the context.
        Parameters:
        name - the variable name, must not be null, remember that the name will be normalized and will be entirely in lower case
        Returns:
        this preprocessor context
        See Also:
        Value

      • removeGlobalVariable

        public PreprocessorContext removeGlobalVariable​(java.lang.String name)
        Remove a global variable value from the context.
        Parameters:
        name - the variable name, must not be null, remember that the name will be normalized and will be entirely in lower case
        Returns:
        this preprocessor context
        See Also:
        Value

      • getLocalVariable

        public Value getLocalVariable​(java.lang.String name)
        Get a local variable value
        Parameters:
        name - the name for the variable, it can be null. The name will be normalized to allowed one.
        Returns:
        null either if the name is null or the variable is not found, otherwise its value

      • containsLocalVariable

        public boolean containsLocalVariable​(java.lang.String name)
        Check that a local variable for a name is presented
        Parameters:
        name - the checking name, it will be normalized to the support format and can be null
        Returns:
        false either if the name is null or there is not any local variable for the name, otherwise true

      • clearLocalVariables

        public PreprocessorContext clearLocalVariables()
        Remove all local variables from the inside storage
        Returns:
        this preprocessor context

      • setGlobalVariable

        public PreprocessorContext setGlobalVariable​(java.lang.String name,
                                             Value value)
        Set a global variable value
        Parameters:
        name - the variable name, it must not be null and will be normalized to the supported format
        value - the variable value, it must not be null
        Returns:
        this preprocessor context

      • containsGlobalVariable

        public boolean containsGlobalVariable​(java.lang.String name)
        Check that there is a named global variable in the inside storage
        Parameters:
        name - the checking name, it will be normalized to the supported format, it can be null
        Returns:
        true if such variable is presented for its name in the inside storage, otherwise false (also it is false if the name is null)

      • findVariableForName

        public Value findVariableForName​(java.lang.String name,
                                 boolean enforceUnknownVarAsNull)
        Find value among local and global variables for a name. It finds in the order: special processors, local variables, global variables
        Parameters:
        name - the name for the needed variable, it will be normalized to the supported format
        enforceUnknownVarAsNull - if true then state of the unknownVariableAsFalse flag in context will be ignored
        Returns:
        false if either the variable is not found or the name is null, otherwise the variable value

      • isGlobalVariable

        public boolean isGlobalVariable​(java.lang.String variableName)
        Check that there is a global variable with such name.
        Parameters:
        variableName - a name to be checked, can be null
        Returns:
        false if there is not such variable or it is null, true if such global or special variable exists

      • isLocalVariable

        public boolean isLocalVariable​(java.lang.String variableName)
        Check that there is a local variable with such name.
        Parameters:
        variableName - a name to be checked, can be null
        Returns:
        false if there is not such variable or it is null, true if such local variable exists

      • setVerbose

        public PreprocessorContext setVerbose​(boolean flag)
        Set the verbose flag
        Parameters:
        flag - true if the preprocessor must be verbose, otherwise false
        Returns:
        this preprocessor context

      • isVerbose

        public boolean isVerbose()
        Check the verbose flag
        Returns:
        true if the preprocessor must be verbose, otherwise false

      • setCompareDestination

        public PreprocessorContext setCompareDestination​(boolean flag)
        Set the flag to check before saving if the content changed.
        Parameters:
        flag - true if to check, false otherwise
        Returns:
        the preprocessor context

      • isCompareDestination

        public boolean isCompareDestination()
        Check the flag to check content of existing file before saving.
        Returns:
        true if the content should be checked and new content must not be replaced if it is the same

      • setKeepLines

        public PreprocessorContext setKeepLines​(boolean flag)
        Set the flag to keep lines as commented ones
        Parameters:
        flag - true if the preprocessor must keep non-executing lines, otherwise false
        Returns:
        this preprocessor context

      • isKeepLines

        public boolean isKeepLines()
        Check that the preprocessor must keep lines as commented ones
        Returns:
        true if the preprocessor must keep lines, false otherwise

      • isCopyFileAttributes

        public boolean isCopyFileAttributes()
        Check that the preprocessor must copy file attributes.
        Returns:
        true if the preprocessor must copy file attributes, false otherwise.

      • setCopyFileAttributes

        public PreprocessorContext setCopyFileAttributes​(boolean value)
        Set the flag to copy file attributes.
        Parameters:
        value - true if file attributes must be copied, false otherwise.
        Returns:
        the preprocessor context

      • setPreprocessorExtension

        public PreprocessorContext setPreprocessorExtension​(PreprocessorExtension extension)
        Set a preprocessor extension, it is a module implements the PreprocessorExtension interface which can process and get some calls from a preprocessor during its work
        Parameters:
        extension - an object implements the PreprocessorExtension interface, it can be null
        Returns:
        this preprocessor context
        See Also:
        PreprocessorExtension

      • getPreprocessorExtension

        public PreprocessorExtension getPreprocessorExtension()
        Get the current preprocessor extension
        Returns:
        the current preprocessor extension, it can be null
        See Also:
        PreprocessorExtension

      • setInCharacterEncoding

        public PreprocessorContext setInCharacterEncoding​(java.lang.String characterEncoding)
        Set the character encoding for reading texts, it must be supported by the Java platform else an exception will be thrown
        Parameters:
        characterEncoding - a character encoding as a String, it must not be null and must be supported by the Java platform
        Returns:
        this preprocessor context

      • setOutCharacterEncoding

        public PreprocessorContext setOutCharacterEncoding​(java.lang.String characterEncoding)
        Set the output texts character encoding, it must be supported by the Java platform else an exception will be thrown
        Parameters:
        characterEncoding - a character encoding as a String, it must not be null and must be supported by the Java platform
        Returns:
        this preprocessor context

      • getInCharacterEncoding

        public java.lang.String getInCharacterEncoding()
        Get the current character encoding for text reading
        Returns:
        the current read texts character encoding as a String

      • getOutCharacterEncoding

        public java.lang.String getOutCharacterEncoding()
        Get the current character encoding for text writing
        Returns:
        the current text writing character encoding as a String

      • createDestinationFileForPath

        public java.io.File createDestinationFileForPath​(java.lang.String path)
        It allows to create a File object for its path subject to the destination directory path
        Parameters:
        path - the path to the file, it must not be null
        Returns:
        a generated File object for the path

      • findFileInSourceFolder

        public java.io.File findFileInSourceFolder​(java.lang.String path)
                                    throws java.io.IOException
        It finds a file for its path among files in source folder, it is prohibited to return files out of preprocessing folders.
        Parameters:
        path - the path to the needed file, it must not be null and the file must exist and be a file and be among files in preprocessing source folders
        Returns:
        detected file object for the path
        Throws:
        java.io.IOException - if it is impossible to find a file for the path

      • addConfigFile

        public void addConfigFile​(java.io.File file)
        Add a configuration file, it is a file which contains directives and global variable definitions
        Parameters:
        file - a file, it must not be null

      • getConfigFiles

        @MustNotContainNull
public java.io.File[] getConfigFiles()
        Get array of current registered configuration files
        Returns:
        a file array contains the current registered configuration files

      • produceNewPreprocessingState

        public PreprocessingState produceNewPreprocessingState​(FileInfoContainer fileContainer,
                                                       int phaseIndex)
                                                throws java.io.IOException
        Generate new preprocessing state object, also the new preprocessing state will be saved as the current one in the context
        Parameters:
        fileContainer - a file container which will be using the preprocessor state, it must not be null
        phaseIndex - index of phase (0 - global, 1 - preprocessing)
        Returns:
        new generated preprocessor state
        Throws:
        java.io.IOException - it will be throws if there is any error in opening and reading operations

      • produceNewPreprocessingState

        public PreprocessingState produceNewPreprocessingState​(FileInfoContainer fileContainer,
                                                       TextFileDataContainer textContainer)
        Generate new preprocessing state for a file container and a text container, also the new preprocessing state will be saved as the current one in the context
        Parameters:
        fileContainer - the file container to be used to create the new preprocessing state, it must not be null
        textContainer - the text container to be used to create the new preprocessing state, it must not be null
        Returns:
        new generated preprocessing state

      • getPreprocessingState

        public PreprocessingState getPreprocessingState()
        Get the last generated preprocessing state, it is the current one
        Returns:
        the last generated preprocessing state

      • makeException

        public PreprocessorException makeException​(java.lang.String text,
                                           java.lang.Throwable cause)
        Prepare exception with message and cause, or return cause if it is a preprocessor exception
        Parameters:
        text - the message text, must not be null
        cause - the cause, it can be null
        Returns:
        prepared exception with additional information

      • logForVerbose

        public void logForVerbose​(java.lang.String str)