Annotations

Maps a SysML block to its corresponding Java delegate. AGI recommends that you define one unique interface with a @DelegateFor annotation and then provide different concrete implementations as desired. While an interface is not required, it can be useful for maintaining the delegate implementations in cases where the SysML structure may change over time. That way, updating the interfaces (for instance by using the Code Generator) will provide a way for the compiler to help update code to be consistent with the SysML.

You can use the Moxie-Base::Configuration::MoxieJavaDelegate stereotype to reference any concrete class derived from a class or interface annotated with @DelegateFor. You can then have two or more concrete implementations for a given SysML type, and by applying this stereotype to individual SysML instances, you can specify which Java implementation to use with each instance.

If more than one delegate references the same qualified name in its @DelegateFor annotation, an exception will be thrown at simulation runtime.

@DelegateFor("Structure::Passenger")
public interface Passenger extends SpatialEntity { ... }

If two or more classes derive from a base class or interface annotated with @DelegateFor, the @DefaultDelegate annotation informs the Moxie Engine which one should be used in the simulation. To override the specified @DefaultDelegate without having to recompile your code, apply the Moxie-Base::Configuration::MoxieJavaDelegate stereotype to that SysML instance. Similarly to @DelegateFor, only one @DefaultDelegate may be present for any Java class which derives from a @DelegateFor base class or interface. If there are zero concrete classes specified with the @DefaultDelegate annotation and the SysML instance has no MoxieJavaDelegate stereotype applied, Moxie will first attempt to find an abstract class or interface to use. If this fails, it will attempt to provide an implementation for the element automatically using default behaviors.

In the following snippet, both AdultPassenger and ChildPassenger implement Passenger, which is annotated with @DelegateFor("Structure::Passenger"). In this case, AdultPassenger will be used, since it is annotated with @DefaultDelegate.

@DefaultDelegate
public class AdultPassenger implements Passenger { ... }

public class ChildPassenger implements Passenger { ... }

This annotation is optional.

By annotating a class or interface with @AutoDelegateImplementation, it indicates to the Moxie Engine that it should provide a default implementation automatically for any properties or operations that haven't been implemented explicitly. You can find more details in the Auto Implementation topic.

In the following snippet, the @AutoDelegateImplementation annotation will inform the Moxie Engine to implement any properties or operations that exist in the Passenger block but are not implemented in the Java delegate.

@AutoDelegateImplementation
@DefaultDelegate
public class AdultPassenger implements Passenger { ... }

This annotation is optional.

This annotation enables you to map enumeration literals in your model to Java enum constants. In particular, if there is a difference in spelling or formatting between a model enumeration literal and its Java counterpart, this annotation will address that for you. If no such annotation is specified, Moxie attempts to map to a literal with the same spelling and formatting on both sides.

In the following snippet, the enumeration literals for the model do not match their Java enum constant counterparts.

@DelegateFor("Structure::BalloonStatus")
public enum SampleBalloonStatus {
    @EnumerationLiteralName("Grounded")
    WAITING,
    @EnumerationLiteralName("Loading")
    LOADING,
    @EnumerationLiteralName("InFlight")
    IN_FLIGHT,
    @EnumerationLiteralName("Unloading")
    UNLOADING
}

Annotates an injection constructor parameter and retrieves the dependency by name. The dependencies for existing tools are listed with their corresponding AnalysisToolController. You can provide custom dependencies to delegates by extending your own AnalysisToolController.

public SampleBalloonOperator(
        @InjectByName("stateMachineRemoteControl") StateMachineRemoteControl stateMachineRemoteControl,
        @InjectByName("timeProvider") TimeProvider timeProvider,
        @InjectBySlot("balloon") Balloon balloon,
        @InjectBySlot("passenger") Passenger passenger,
        @InjectBySlot("launchPadAltitude") FixedScalarValue launchPadAltitude,
        @InjectBySlot("targetAltitude") FixedScalarValue targetAltitude,
        @InjectBySlot("maxFlightDuration") DefaultFixedDuration maxFlightDuration) { ... }

Annotates an injection constructor parameter and provides the value found in the slot for the corresponding property of the Instance Specification.

If this annotation is specified but a slot value is not provided in the instance specification, a NoSuchElementException is thrown at the start of the simulation.

If a slot value is provided in the instance specification, then the system will perform a wire-up to set the value whether or not this parameter is present in the constructor. This simply provides a useful way to gain access to the value at construction time. The type of the parameter must match its Java equivalent as specified by the @DelegateFor annotation. In order to circumvent circular dependencies between instances, you may instead specify the type of the parameter as javax.inject.Provider<T> (for example, Provider<OtherDelegateType>). See the wire-up section of Properties and Operations for more details on how the system handles initializing values.

The InjectStereotype annotation enables you to accept an instance of any custom stereotype applied to the delegate instance in SysML. The only stipulation is that the Java class CustomStereotypeImplementation is registered with the Delegate Provider. If no such stereotype is applied, the parameter value will be null.