001: // THIS SOFTWARE IS PROVIDED BY SOFTARIS PTY.LTD. AND OTHER METABOSS
002: // CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING,
003: // BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
004: // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SOFTARIS PTY.LTD.
005: // OR OTHER METABOSS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
006: // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
007: // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
008: // OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
009: // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
010: // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
011: // EVEN IF SOFTARIS PTY.LTD. OR OTHER METABOSS CONTRIBUTORS ARE ADVISED OF THE
012: // POSSIBILITY OF SUCH DAMAGE.
013: //
014: // Copyright 2000-2005 © Softaris Pty.Ltd. All Rights Reserved.
015: package com.metaboss.sdlctools.services.codegenerationstylesheet;
016:
017: /** This structure contains the stylesheet (set of names) pertained to the particular event subscription operation */
018: public final class STEventSubscriptionOperationStylesheet {
019: private String mEventSubscriptionOperationRef = null;
020: private String mSubscribeMethodName = null;
021: private String mUnsubscribeMethodName = null;
022: private String mInputClassName = null;
023: private String mInputClassFullName = null;
024: private String mInputProxyInnerClassName = null;
025: private String mInputProxyOuterClassName = null;
026: private String mInputProxyTranslatorInnerClassName = null;
027: private String mInputProxyTranslatorOuterClassName = null;
028: private String mInputValidatorInnerClassName = null;
029: private String mInputValidatorOuterClassName = null;
030: private String mResultClassName = null;
031: private String mResultClassFullName = null;
032: private String mResultProxyInnerClassName = null;
033: private String mResultProxyOuterClassName = null;
034: private String mResultProxyTranslatorInnerClassName = null;
035: private String mResultProxyTranslatorOuterClassName = null;
036: private String mInvalidOperationInputOperationOutputMessageName = null;
037:
038: /** Getter for the unique identifier of the corresponding operation */
039: public String getEventSubscriptionOperationRef() {
040: return mEventSubscriptionOperationRef;
041: }
042:
043: /** Getter for the name of the method realising the subscribe operation */
044: public String getSubscribeMethodName() {
045: return mSubscribeMethodName;
046: }
047:
048: /** Getter for the name of the method realising the unsubscribe operation */
049: public String getUnsubscribeMethodName() {
050: return mUnsubscribeMethodName;
051: }
052:
053: /** Getter for the name of the class realising the input structure for this operation */
054: public String getInputClassName() {
055: return mInputClassName;
056: }
057:
058: /** Getter for the full name (package and service name and name) of the class realising the input structure for this operation */
059: public String getInputClassFullName() {
060: return mInputClassFullName;
061: }
062:
063: /** Getter for the name of the proxy class to the input structure of this operation.
064: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
065: * same data but may use different datatypes depending on the nature of the technolgy.
066: * Note that this proxy class may reside in any package as chosen by generator
067: * (in fact there will most probably be more than one implementation each in different package)
068: * Also note that the name formed here is only unique inside the service (hence the word "inner" in the name.)
069: * Use getInputProxyOuterClassName() to get the "outer" class name which would somehow include the service name
070: * and therefore will be unique outside the service */
071: public String getInputProxyInnerClassName() {
072: return mInputProxyInnerClassName;
073: }
074:
075: /** Getter for the name of the proxy class to the input structure of this operation.
076: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
077: * same data but may use different datatypes depending on the nature of the technolgy.
078: * Note that this proxy class may reside in any package as chosen by generator
079: * (in fact there will most probably be more than one implementation each in different package)
080: * Also note that the name formed here is unique outside the service scope (hence the word "outer" in the name.)
081: * this means that the name somehow includes the service name and may therefore be longer than necessary
082: * if class is placed inside the service scope. Use getInputProxyInnerClassName() to get the "inner"
083: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
084: public String getInputProxyOuterClassName() {
085: return mInputProxyOuterClassName;
086: }
087:
088: /** Getter for the name of the proxy translator class between input proxy structure and input structure
089: * Note that this proxy translator class may reside in any package as chosen by generator
090: * (in fact there will most probably be more than one implementation each in different package)
091: * Also note that the name formed here is only unique inside the service (hence the word "inner" in the name.)
092: * Use getInputProxyTranslatorOuterClassName() to get the "outer" class name which would somehow include the service name
093: * and therefore will be unique outside the service */
094: public String getInputProxyTranslatorInnerClassName() {
095: return mInputProxyTranslatorInnerClassName;
096: }
097:
098: /** Getter for the name of the proxy translator class between input proxy structure and input structure
099: * Note that this proxy translator class may reside in any package as chosen by generator
100: * (in fact there will most probably be more than one implementation each in different package)
101: * Also note that the name formed here is unique outside the service scope (hence the word "outer" in the name.)
102: * this means that the name somehow includes the service name and may therefore be longer than necessary
103: * if class is placed inside the service scope. Use getInputProxyTranslatorInnerClassName() to get the "inner"
104: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
105: public String getInputProxyTranslatorOuterClassName() {
106: return mInputProxyTranslatorOuterClassName;
107: }
108:
109: /** Getter for the name of the class realising the result structure for this operation */
110: public String getResultClassName() {
111: return mResultClassName;
112: }
113:
114: /** Getter for the full name (package and service name and name) of the class realising the result structure for this operation */
115: public String getResultClassFullName() {
116: return mResultClassFullName;
117: }
118:
119: /** Getter for the name of the proxy class to the result structure of this operation.
120: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
121: * same data but may use different datatypes depending on the nature of the technolgy.
122: * Note that this proxy class may reside in any package as chosen by generator
123: * (in fact there will most probably be more than one implementation each in different package)
124: * Also note that the name formed here is only unique inside the service scope (hence the word "inner" in the name.)
125: * Use getResultProxyOuterClassName() to get the "outer" class name which would somehow include the service name
126: * and therefore will be unique outside the service scope */
127: public String getResultProxyInnerClassName() {
128: return mResultProxyInnerClassName;
129: }
130:
131: /** Getter for the name of the proxy translator class between result proxy structure and result structure
132: * Note that this proxy translator class may reside in any package as chosen by generator
133: * (in fact there will most probably be more than one implementation each in different package)
134: * Also note that the name formed here is only unique inside the service scope (hence the word "inner" in the name.)
135: * Use getResultProxyTranslatorOuterClassName() to get the "outer" class name which would somehow include the service name
136: * and therefore will be unique outside the service scope */
137: public String getResultProxyTranslatorInnerClassName() {
138: return mResultProxyTranslatorInnerClassName;
139: }
140:
141: /** Getter for the name of the proxy class to the result structure of this operation.
142: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
143: * same data but may use different datatypes depending on the nature of the technolgy.
144: * Note that this proxy class may reside in any package as chosen by generator
145: * (in fact there will most probably be more than one implementation each in different package)
146: * Also note that the name formed here is unique outside the service scope (hence the word "outer" in the name.)
147: * this means that the name somehow includes the service name and may therefore be longer than necessary
148: * if class is placed inside the service scope. Use getResultProxyInnerClassName() to get the "inner"
149: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
150: public String getResultProxyOuterClassName() {
151: return mResultProxyOuterClassName;
152: }
153:
154: /** Getter for the name of the proxy translator class between result proxy structure and result structure
155: * Note that this proxy translator class may reside in any package as chosen by generator
156: * (in fact there will most probably be more than one implementation each in different package)
157: * Also note that the name formed here is unique outside the service scope (hence the word "outer" in the name.)
158: * this means that the name somehow includes the service name and may therefore be longer than necessary
159: * if class is placed inside the service scope. Use getResultProxyTranslatorInnerClassName() to get the "inner"
160: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
161: public String getResultProxyTranslatorOuterClassName() {
162: return mResultProxyTranslatorOuterClassName;
163: }
164:
165: /** Getter for the name of the output message which should be returned if
166: * operation has detected invalid input. */
167: public String getInvalidOperationInputOperationOutputMessageName() {
168: return mInvalidOperationInputOperationOutputMessageName;
169: }
170:
171: /** Setter for the unique identifier of the corresponding operation */
172: public void setEventSubscriptionOperationRef(
173: String pEventSubscriptionOperationRef) {
174: mEventSubscriptionOperationRef = pEventSubscriptionOperationRef;
175: }
176:
177: /** Setter for the name of the method realising the subscribe operation */
178: public void setSubscribeMethodName(String pSubscribeMethodName) {
179: mSubscribeMethodName = pSubscribeMethodName;
180: }
181:
182: /** Setter for the name of the method realising the unsubscribe operation */
183: public void setUnsubscribeMethodName(String pUnsubscribeMethodName) {
184: mUnsubscribeMethodName = pUnsubscribeMethodName;
185: }
186:
187: /** Setter for the name of the class realising the input structure for this operation */
188: public void setInputClassName(String pInputClassName) {
189: mInputClassName = pInputClassName;
190: }
191:
192: /** Setter for the full name (package and service name and name) of the class realising the input structure for this operation */
193: public void setInputClassFullName(String pInputClassFullName) {
194: mInputClassFullName = pInputClassFullName;
195: }
196:
197: /** Setter for the name of the proxy class to the input structure of this operation.
198: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
199: * same data but may use different datatypes depending on the nature of the technolgy.
200: * Note that this proxy class may reside in any package as chosen by generator
201: * (in fact there will most probably be more than one implementation each in different package)
202: * Also note that the name expected here is only unique inside the service scope (hence the word "inner" in the name.)
203: * Use setInputProxyOuterClassName() to set the "outer" class name which would somehow include the service name
204: * and therefore will be unique outside the service scope */
205: public void setInputProxyInnerClassName(
206: String pInputProxyInnerClassName) {
207: mInputProxyInnerClassName = pInputProxyInnerClassName;
208: }
209:
210: /** Setter for the name of the proxy class to the input structure of this operation.
211: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
212: * same data but may use different datatypes depending on the nature of the technolgy.
213: * Note that this proxy class may reside in any package as chosen by generator
214: * (in fact there will most probably be more than one implementation each in different package)
215: * Also note that the name expected here is only unique inside the service scope (hence the word "inner" in the name.)
216: * Use setInputProxyOuterClassName() to set the "outer" class name which would somehow include the service name
217: * and therefore will be unique outside the service scope */
218: public void setInputProxyOuterClassName(
219: String pInputProxyOuterClassName) {
220: mInputProxyOuterClassName = pInputProxyOuterClassName;
221: }
222:
223: /** Setter for the name of the proxy translator class between input proxy structure and input structure
224: * Note that this proxy translator class may reside in any package as chosen by generator
225: * (in fact there will most probably be more than one implementation each in different package)
226: * Also note that the name expected here is only unique inside the service scope (hence the word "inner" in the name.)
227: * Use setInputProxyTranslatorOuterClassName() to set the "outer" class name which would somehow include the service name
228: * and therefore will be unique outside the service scope */
229: public void setInputProxyTranslatorInnerClassName(
230: String pInputProxyTranslatorInnerClassName) {
231: mInputProxyTranslatorInnerClassName = pInputProxyTranslatorInnerClassName;
232: }
233:
234: /** Setter for the name of the proxy translator class between input proxy structure and input structure
235: * Note that this proxy translator class may reside in any package as chosen by generator
236: * (in fact there will most probably be more than one implementation each in different package)
237: * Also note that the name expected here is unique outside the service scope (hence the word "outer" in the name.)
238: * this means that the name somehow includes the service name and may therefore be longer than necessary
239: * if class is placed inside the service scope. Use setInputProxyTranslatorInnerClassName() to set the "inner"
240: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
241: public void setInputProxyTranslatorOuterClassName(
242: String pInputProxyTranslatorOuterClassName) {
243: mInputProxyTranslatorOuterClassName = pInputProxyTranslatorOuterClassName;
244: }
245:
246: /** Setter for the name of the class realising the result structure for this operation */
247: public void setResultClassName(String pResultClassName) {
248: mResultClassName = pResultClassName;
249: }
250:
251: /** Setter for the full name (package and service name and name) of the class realising the result structure for this operation */
252: public void setResultClassFullName(String pResultClassFullName) {
253: mResultClassFullName = pResultClassFullName;
254: }
255:
256: /** Setter for the name of the proxy class to the result structure of this operation.
257: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
258: * same data but may use different datatypes depending on the nature of the technolgy.
259: * Note that this proxy class may reside in any package as chosen by generator
260: * (in fact there will most probably be more than one implementation each in different package)
261: * Also note that the name expected here is only unique inside the service scope (hence the word "inner" in the name.)
262: * Use setResultProxyOuterClassName() to set the "outer" class name which would somehow include the service name
263: * and therefore will be unique outside the service scope */
264: public void setResultProxyInnerClassName(
265: String pResultProxyInnerClassName) {
266: mResultProxyInnerClassName = pResultProxyInnerClassName;
267: }
268:
269: /** Setter for the name of the proxy class to the result structure of this operation.
270: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
271: * same data but may use different datatypes depending on the nature of the technolgy.
272: * Note that this proxy class may reside in any package as chosen by generator
273: * (in fact there will most probably be more than one implementation each in different package)
274: * Also note that the name expected here is unique outside the service scope (hence the word "outer" in the name.)
275: * this means that the name somehow includes the service name and may therefore be longer than necessary
276: * if class is placed inside the service scope. Use setResultProxyInnerClassName() to set the "inner"
277: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
278: public void setResultProxyOuterClassName(
279: String pResultProxyOuterClassName) {
280: mResultProxyOuterClassName = pResultProxyOuterClassName;
281: }
282:
283: /** Setter for the name of the proxy translator class between result proxy structure
284: * Note that this proxy translator class may reside in any package as chosen by generator
285: * (in fact there will most probably be more than one implementation each in different package)
286: * Also note that the name expected here is only unique inside the service scope (hence the word "inner" in the name.)
287: * Use setResultProxyTranslatorOuterClassName() to set the "outer" class name which would somehow include the service name
288: * and therefore will be unique outside the service scope */
289: public void setResultProxyTranslatorInnerClassName(
290: String pResultProxyTranslatorInnerClassName) {
291: mResultProxyTranslatorInnerClassName = pResultProxyTranslatorInnerClassName;
292: }
293:
294: /** Setter for the name of the proxy translator class between result proxy structure
295: * Note that this proxy translator class may reside in any package as chosen by generator
296: * (in fact there will most probably be more than one implementation each in different package)
297: * Also note that the name expected here is unique outside the service scope (hence the word "outer" in the name.)
298: * this means that the name somehow includes the service name and may therefore be longer than necessary
299: * if class is placed inside the service scope. Use setResultProxyTranslatorInnerClassName() to set the "inner"
300: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
301: public void setResultProxyTranslatorOuterClassName(
302: String pResultProxyTranslatorOuterClassName) {
303: mResultProxyTranslatorOuterClassName = pResultProxyTranslatorOuterClassName;
304: }
305:
306: /** Setter for the name of the output message which should be returned if
307: * operation has detected invalid input. */
308: public void setInvalidOperationInputOperationOutputMessageName(
309: String pOperationOutputMessageName) {
310: mInvalidOperationInputOperationOutputMessageName = pOperationOutputMessageName;
311: }
312:
313: /** Getter for the name of the validator inner class to this structure. Use it to name the
314: * utility classes which perform validation of the operations input data. */
315: public String getInputValidatorInnerClassName() {
316: return mInputValidatorInnerClassName;
317: }
318:
319: /** Setter for the name of the validator inner class to this structure. Use it to name the
320: * utility classes which perform validation of the operations input data. */
321: public void setInputValidatorInnerClassName(
322: String pInputValidatorInnerClassName) {
323: mInputValidatorInnerClassName = pInputValidatorInnerClassName;
324: }
325:
326: /** Getter for the name of the validator outer class to this structure. Use it to name the
327: * utility classes which perform validation of the operations input data. */
328: public String getInputValidatorOuterClassName() {
329: return mInputValidatorOuterClassName;
330: }
331:
332: /** Setter for the name of the validator outer class to this structure. Use it to name the
333: * utility classes which perform validation of the operations input data. */
334: public void setInputValidatorOuterClassName(
335: String pInputValidatorOuterClassName) {
336: mInputValidatorOuterClassName = pInputValidatorOuterClassName;
337: }
338: }
|