Xcos refactoring: move link classes
[scilab.git] / scilab / modules / xcos / src / java / org / scilab / modules / xcos / link / LinkPortMap.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - DIGITEO - Clement DAVID
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
10  *
11  */
12
13 package org.scilab.modules.xcos.link;
14
15 import org.scilab.modules.xcos.port.BasicPort;
16 import org.scilab.modules.xcos.port.command.CommandPort;
17 import org.scilab.modules.xcos.port.control.ControlPort;
18 import org.scilab.modules.xcos.port.input.InputPort;
19 import org.scilab.modules.xcos.port.output.OutputPort;
20
21 /**
22  * Enum used to get the links and ports class from ids.
23  */
24 public enum LinkPortMap {
25     /**
26      * Explicit input port mapping
27      */
28     EX_INPUT(ExplicitLink.class, InputPort.class, false),
29     /**
30      * Implicit input port mapping
31      *
32      * Note: for implicit link, the from and to start flag is inverted. So here
33      * the {@link #isStart()} is inverted too.
34      */
35     IM_INPUT(ImplicitLink.class, InputPort.class, false),
36     /**
37      * Explicit output port mapping
38      */
39     EX_OUTPUT(ExplicitLink.class, OutputPort.class, true),
40     /**
41      * Implicit output port mapping
42      *
43      * Note: for implicit link, the from and to start flag is inverted. So here
44      * the {@link #isStart()} is inverted too.
45      */
46     IM_OUTPUT(ImplicitLink.class, OutputPort.class, true),
47     /**
48      * Control port mapping
49      */
50     CONTROL(CommandControlLink.class, ControlPort.class, false),
51     /**
52      * Command port mapping
53      */
54     COMMAND(CommandControlLink.class, CommandPort.class, true);
55
56     private final Class <? extends BasicLink > linkKlass;
57     private final Class <? extends BasicPort > portKlass;
58     private final boolean isStart;
59
60     /**
61      * Default constructor
62      *
63      * @param linkKlass
64      *            the associated link class
65      * @param portKlass
66      *            the associated port class
67      * @param isStart
68      *            is this port a start point ?
69      */
70     private LinkPortMap(Class <? extends BasicLink > linkKlass, Class <? extends BasicPort > portKlass, boolean isStart) {
71         this.linkKlass = linkKlass;
72         this.portKlass = portKlass;
73         this.isStart = isStart;
74     }
75
76     /**
77      * @return the associated link class
78      */
79     public final Class <? extends BasicLink > getLinkKlass() {
80         return linkKlass;
81     }
82
83     /**
84      * @return the associated port class
85      */
86     public final Class <? extends BasicPort > getPortKlass() {
87         return portKlass;
88     }
89
90     /**
91      * @return is this port a start point ?
92      */
93     public final boolean isStart() {
94         return isStart;
95     }
96
97     /*
98      * Static methods
99      */
100
101     /**
102      * Get the enum value.
103      *
104      * This method doesn't pass the cyclomatic complexity but is really simple
105      * as doesn't contains any operations but just a reasonable mapping.
106      *
107      * @param type
108      *            the type field
109      * @param isStart
110      *            is this port a start point ?
111      * @return the enum value
112      */
113     // CSOFF: CyclomaticComplexity
114     public static LinkPortMap getLinkPortMap(int type, boolean isStart) {
115         LinkPortMap ret = null;
116
117         if (type == 1 && !isStart) {
118             ret = LinkPortMap.EX_INPUT;
119         } else if (type == 1 && isStart) {
120             ret = LinkPortMap.EX_OUTPUT;
121         } else if (type == 2 && !isStart) {
122             ret = LinkPortMap.IM_INPUT;
123         } else if (type == 2 && isStart) {
124             ret = LinkPortMap.IM_OUTPUT;
125         } else if (type == -1 && !isStart) {
126             ret = LinkPortMap.CONTROL;
127         } else if (type == -1 && isStart) {
128             ret = LinkPortMap.COMMAND;
129         }
130
131         return ret;
132     }
133
134     // CSON: CyclomaticComplexity
135
136     /**
137      * Get the start value from the xcos instance
138      *
139      * @param port
140      *            the instance
141      * @return 1.0 if is a start point, 0.0 otherwise.
142      */
143     public static double isStart(BasicPort port) {
144         if (port instanceof InputPort || port instanceof ControlPort) {
145             return 1.0;
146         } else {
147             return 0.0;
148         }
149     }
150
151     /**
152      * Get the link class associated with the type
153      *
154      * @param type
155      *            the type field
156      * @return the link class
157      */
158     public static Class <? extends BasicLink > getLinkClass(int type) {
159         // false or true will return the same link class
160         return getLinkPortMap(type, false).getLinkKlass();
161     }
162
163     /**
164      * Get the port class associated with the link class.
165      *
166      * @param klass
167      *            the link class
168      * @param isStart
169      *            if an output port must be found.
170      * @return the port class
171      */
172     public static Class <? extends BasicPort > getPortClass(Class <? extends BasicLink > klass, boolean isStart) {
173         for (LinkPortMap pt : values()) {
174             if (pt.getLinkKlass() == klass && pt.isStart() == isStart) {
175                 return pt.getPortKlass();
176             }
177         }
178
179         return null;
180     }
181 }