View Javadoc
1   // license-header java merge-point
2   //
3   // Attention: generated code (by Metafacade.vsl) - do not modify!
4   //
5   package org.andromda.metafacades.uml;
6   
7   import java.util.List;
8   
9   /**
10   * Represents a use case used in the "front end" of an application.
11   *
12   * Metafacade interface to be used by AndroMDA cartridges.
13   */
14  public interface FrontEndUseCase
15      extends UseCaseFacade
16  {
17      /**
18       * Indicates the metafacade type (used for metafacade mappings).
19       *
20       * @return boolean always <code>true</code>
21       */
22      public boolean isFrontEndUseCaseMetaType();
23  
24      /**
25       * The actions for this use-case. This will include the initial action to start the use-case.
26       * @return List<FrontEndAction>
27       */
28      public List<FrontEndAction> getActions();
29  
30      /**
31       * Returns the activity graph describing this use-case in more detail.
32       * @return FrontEndActivityGraph
33       */
34      public FrontEndActivityGraph getActivityGraph();
35  
36      /**
37       * All roles that directly or indirectly related to any "front-end" use cases.
38       * @return List<Role>
39       */
40      public List<Role> getAllRoles();
41  
42      /**
43       * Returns all struts use-cases in this "front end" application.
44       * @return List<FrontEndUseCase>
45       */
46      public List<FrontEndUseCase> getAllUseCases();
47  
48      /**
49       * Returns the controller for this use-case.
50       * @return FrontEndController
51       */
52      public FrontEndController getController();
53  
54      /**
55       * The first view of this use case, this may actually return a view of another use case if the
56       * first is found by traveling through the final state.
57       * @return FrontEndView
58       */
59      public FrontEndView getInitialView();
60  
61      /**
62       * The final states linking to this use case
63       * @return List<FrontEndFinalState>
64       */
65      public List<FrontEndFinalState> getReferencingFinalStates();
66  
67      /**
68       * Returns all roles that are directly and indirectly associated to this use-case.
69       * @return List<Role>
70       */
71      public List<Role> getRoles();
72  
73      /**
74       * The variables for all views in this use-case. A parameter qualifies to be a variable when it
75       * explicitely and directly receives it via an action.
76       * @return List<FrontEndParameter>
77       */
78      public List<FrontEndParameter> getViewVariables();
79  
80      /**
81       * All views that are part of this use case.
82       * @return List<FrontEndView>
83       */
84      public List<FrontEndView> getViews();
85  
86      /**
87       * True if this use-case is the entry point to the front end.
88       * @return boolean
89       */
90      public boolean isEntryUseCase();
91  
92      /**
93       * Indicates if this use case is "secured".  This is true when there is at least one role
94       * associated to it.
95       * @return boolean
96       */
97      public boolean isSecured();
98  }