Package adams.flow.control

Class CallableActorScreenshot

  • All Implemented Interfaces:
    AdditionalInformationHandler, CleanUpHandler, Destroyable, GlobalInfoSupporter, LoggingLevelHandler, LoggingSupporter, OptionHandler, QuickInfoSupporter, ShallowCopySupporter<Actor>, SizeOfHandler, Stoppable, StoppableWithFeedback, VariablesInspectionHandler, VariableChangeListener, Actor, ControlActor, ErrorHandler, InputConsumer, OutputProducer, Serializable, Comparable
    public class CallableActorScreenshot
extends AbstractActor
implements ControlActor, InputConsumer, OutputProducer
    Takes a screenshot of a callable actor whenever a token passes through.
    The screenshot can either be written to disk (and the input token is forwarded), or the screenshot is forwarded as adams.data.image.BufferedImageContainer (dropping the input token).

    Input/output:
    - accepts:
       adams.flow.core.Unknown
    - generates:
       adams.flow.core.Unknown


    -logging-level <OFF|SEVERE|WARNING|INFO|CONFIG|FINE|FINER|FINEST> (property: loggingLevel)
    The logging level for outputting errors and debugging output.
    default: WARNING
 
    -name <java.lang.String> (property: name)
    The name of the actor.
    default: CallableActorScreenshot
 
    -annotation <adams.core.base.BaseAnnotation> (property: annotations)
    The annotations to attach to this actor.
    default: 
 
    -skip <boolean> (property: skip)
    If set to true, transformation is skipped and the input token is just forwarded 
    as it is.
    default: false
 
    -stop-flow-on-error <boolean> (property: stopFlowOnError)
    If set to true, the flow execution at this level gets stopped in case this 
    actor encounters an error; the error gets propagated; useful for critical 
    actors.
    default: false
 
    -silent <boolean> (property: silent)
    If enabled, then no errors are output in the console; Note: the enclosing 
    actor handler must have this enabled as well.
    default: false
 
    -callable <adams.flow.core.CallableActorReference> (property: callableName)
    The name of the callable actor to use.
    default: unknown
 
    -output-type <FILE|BUFFEREDIMAGE_CONTAINER> (property: outputType)
    The type of output to generate.
    default: FILE
 
    -filename-generator <adams.core.io.AbstractFilenameGenerator> (property: filenameGenerator)
    The filename generator to use.
    default: adams.core.io.DefaultFilenameGenerator
 
    -writer <adams.gui.print.JComponentWriter> (property: writer)
    The writer to use for generating the graphics output.
    default: adams.gui.print.NullWriter
    Author:
    fracpete (fracpete at waikato dot ac dot nz)
    See Also:
    Serialized Form

    • Field Detail

      • BACKUP_COUNTER

        public static final String BACKUP_COUNTER
        the key for storing the current counter in the backup.
        See Also:
        Constant Field Values

      • BACKUP_INPUT

        public static final String BACKUP_INPUT
        the key for storing the input token in the backup.
        See Also:
        Constant Field Values

      • m_InputToken

        protected Token m_InputToken
        the input token.

      • m_OutputToken

        protected Token m_OutputToken
        the output token.

      • m_CallableActor

        protected Actor m_CallableActor
        the callable actor.

      • m_Counter

        protected int m_Counter
        the counter for the screenshots.

      • m_ScreenshotResult

        protected String m_ScreenshotResult
        for storing any exceptions while trying to create a screenshot.

    • Constructor Detail

      • CallableActorScreenshot

        public CallableActorScreenshot()

    • Method Detail

      • reset

        protected void reset()
        Resets the scheme.
        Overrides:
        reset in class AbstractActor

      • setCallableName

        public void setCallableName​(CallableActorReference value)
        Sets the name of the callable actor to use.
        Parameters:
        value - the callable name

      • getCallableName

        public CallableActorReference getCallableName()
        Returns the name of the callable actor in use.
        Returns:
        the callable name

      • callableNameTipText

        public String callableNameTipText()
        Returns the tip text for this property.
        Returns:
        tip text for this property suitable for displaying in the GUI or for listing the options.

      • outputTypeTipText

        public String outputTypeTipText()
        Returns the tip text for this property.
        Returns:
        tip text for this property suitable for displaying in the GUI or for listing the options.

      • setFilenameGenerator

        public void setFilenameGenerator​(AbstractFilenameGenerator value)
        Sets the prefix for the filename in case of auto-generation.
        Parameters:
        value - the prefix (just name, no path)

      • getFilenameGenerator

        public AbstractFilenameGenerator getFilenameGenerator()
        Returns the prefix for the filename in case of auto-generation.
        Returns:
        the panel provider in use

      • filenameGeneratorTipText

        public String filenameGeneratorTipText()
        Returns the tip text for this property.
        Returns:
        tip text for this property suitable for displaying in the GUI or for listing the options.

      • setWriter

        public void setWriter​(JComponentWriter value)
        Sets the writer.
        Parameters:
        value - the writer

      • getWriter

        public JComponentWriter getWriter()
        Returns the writer.
        Returns:
        the writer

      • writerTipText

        public String writerTipText()
        Returns the tip text for this property.
        Returns:
        tip text for this property suitable for displaying in the GUI or for listing the options.

      • findCallableActor

        protected Actor findCallableActor()
        Tries to find the callable actor referenced by its callable name.
        Returns:
        the callable actor or null if not found

      • accepts

        public Class[] accepts()
        Returns the class that the consumer accepts.
        Specified by:
        accepts in interface InputConsumer
        Returns:
        adams.flow.core.Unknown.class

      • input

        public void input​(Token token)
        Does nothing.
        Specified by:
        input in interface InputConsumer
        Parameters:
        token - the token to accept and process

      • hasInput

        public boolean hasInput()
        Returns whether an input token is currently present.
        Specified by:
        hasInput in interface InputConsumer
        Returns:
        true if input token present

      • currentInput

        public Token currentInput()
        Returns the current input token, if any.
        Specified by:
        currentInput in interface InputConsumer
        Returns:
        the input token, null if none present

      • generateFilename

        protected PlaceholderFile generateFilename()
        Generates the filename for the output.
        Returns:
        the file

      • doExecute

        protected String doExecute()
        Executes the flow item.
        Specified by:
        doExecute in class AbstractActor
        Returns:
        null if everything is fine, otherwise error message

      • execute

        public String execute()
        Executes the flow item.
        Specified by:
        execute in interface Actor
        Overrides:
        execute in class AbstractActor
        Returns:
        null if everything is fine, otherwise error message

      • generates

        public Class[] generates()
        Returns the class of objects that it generates.
        Specified by:
        generates in interface OutputProducer
        Returns:
        adams.flow.core.Unknown.class

      • output

        public Token output()
        Returns the generated token.
        Specified by:
        output in interface OutputProducer
        Returns:
        the generated token

      • hasPendingOutput

        public boolean hasPendingOutput()
        Checks whether there is pending output to be collected after executing the flow item.

        The method is not allowed allowed to return "true" before the actor has been executed. For actors that return an infinite number of tokens, the m_Executed flag can be returned.
        Specified by:
        hasPendingOutput in interface OutputProducer
        Returns:
        true if there is pending output

      • wrapUp

        public void wrapUp()
        Cleans up after the execution has finished.
        Specified by:
        wrapUp in interface Actor
        Overrides:
        wrapUp in class AbstractActor