Package adams.flow.control

Class CloseCallableDisplay

  • All Implemented Interfaces:
    AdditionalInformationHandler, CleanUpHandler, Destroyable, GlobalInfoSupporter, LoggingLevelHandler, LoggingSupporter, OptionHandler, QuickInfoSupporter, ShallowCopySupporter<Actor>, SizeOfHandler, Stoppable, StoppableWithFeedback, VariablesInspectionHandler, VariableChangeListener, Actor, CallableActorUser, ControlActor, ErrorHandler, InputConsumer, OutputProducer, Serializable, Comparable
    public class CloseCallableDisplay
extends AbstractCallableActor
implements ControlActor, InputConsumer, OutputProducer
    Closes the referenced callable graphical actor whenever a token passes through.

    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: CloseCallableDisplay
 
    -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
 
    -optional <boolean> (property: optional)
    If enabled, then the callable actor is optional, ie no error is raised if
    not found, merely ignored.
    default: false
    Author:
    fracpete (fracpete at waikato dot ac dot nz)
    See Also:
    Serialized Form

    • Field Detail

      • m_InputToken

        protected Token m_InputToken
        the input token.

      • m_OutputToken

        protected Token m_OutputToken
        the output token.

    • Constructor Detail

      • CloseCallableDisplay

        public CloseCallableDisplay()
        Default constructor.

      • CloseCallableDisplay

        public CloseCallableDisplay​(CallableActorReference name)
        Allows setting the callable name.
        Parameters:
        name - the reference to use

    • Method Detail

      • findCallableActor

        protected Actor findCallableActor()
        Tries to find the callable actor referenced by its callable name.
        Overrides:
        findCallableActor in class AbstractCallableActor
        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

      • executeCallableActor

        protected String executeCallableActor()
        Executes the callable actor. Derived classes might need to override this method to ensure atomicity.
        Specified by:
        executeCallableActor in class AbstractCallableActor
        Returns:
        null if no error, 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

      • 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

      • 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