Package ptolemy.actor.lib

Class ClassWrapper

  • All Implemented Interfaces:
    java.lang.Cloneable, Actor, Executable, FiringsRecordable, Initializable, TypedActor, Changeable, Debuggable, DebugListener, Derivable, Instantiable, ModelErrorHandler, MoMLExportable, Moveable, Nameable
    public class ClassWrapper
extends TypedAtomicActor
    This actor wraps (an instance of) a Java class specified by the className parameter. The actor has no ports when created. If an input port is added to the actor, the name of the port is interpreted as the name of a method of the Java class. When the actor is fired and a token is received from this input port, the value of the token is treated as the argument(s) for invoking the method. If the method has a return value and the actor has an output port named methodNameResult, the return value is wrapped in a token that is sent to the output port.

    For example, suppose the specified class has a method named foo and the actor has an input port of the same name. If method foo takes no argument, the token received from port foo is treated as the trigger for invoking the method, and its content is ignored. If method foo takes arguments, the input token should be a record token whose field values are used as the arguments. The field labels of the record token should be "arg1", "arg2", etc. For example, if method foo takes two double arguments, the record token "{arg1 = 0.0, arg2 = 1.0}" can be the input. A special case is when method foo takes one argument, the token containing the argument value can be input directly, and does not need to be put into a record token.

    FIXME: Need to set type constraints appropriately. Need (and how) to handle overloaded methods.

    Since:
    Ptolemy II 2.0
    Version:
    $Id$
    Author:
    Xiaojun Liu
    Pt.AcceptedRating:
    Red (liuxj)
    Pt.ProposedRating:
    Red (liuxj)

    • Field Detail

    • Constructor Detail

      • ClassWrapper

        public ClassWrapper​(CompositeEntity container,
                    java.lang.String name)
             throws NameDuplicationException,
                    IllegalActionException
        Construct an actor with the given container and name. In addition to invoking the base class constructor, create the className parameter.
        Parameters:
        container - The container of this actor.
        name - The name of this actor.
        Throws:
        IllegalActionException - If the actor cannot be contained by the proposed container.
        NameDuplicationException - If the container already has an actor with the specified name.

    • Method Detail

      • fire

        public void fire()
          throws IllegalActionException
        Read at most one token from each input port. If an input port has a token, the content of the token is used as argument(s) for invoking (on the wrapped instance or class) the method of the same name as the port. If the method has a return value, the value is wrapped in a token, and is sent to the output port named methodNameResult.
        Specified by:
        fire in interface Executable
        Overrides:
        fire in class AtomicActor<TypedIOPort>
        Throws:
        IllegalActionException - If the method invocation fails.

      • preinitialize

        public void preinitialize()
                   throws IllegalActionException
        Get the Class object of the specified class. Gather method invocation information corresponding to each input port. If at least one method corresponding to a port is not static, create an instance of the specified class.
        Specified by:
        preinitialize in interface Initializable
        Overrides:
        preinitialize in class AtomicActor<TypedIOPort>
        Throws:
        IllegalActionException - If the specified class cannot be loaded, or there is no method of the same name as an input port, or an instance of the class cannot be created.