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 operation */
018: public final class STOperationStylesheet {
019: private String mOperationRef = null;
020: private String mNormalisedName = null;
021: private String mMethodName = 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 getOperationRef() {
040: return mOperationRef;
041: }
042:
043: /** Getter for the normalised name of the element. Normalised name is a
044: * "safe to use in computing" kind of name it must be a single word consisting of
045: * the most basic set of characters (e.g. letters, numbers, underscores) */
046: public String getNormalisedName() {
047: return mNormalisedName;
048: }
049:
050: /** Getter for the name of the method realising the operation */
051: public String getMethodName() {
052: return mMethodName;
053: }
054:
055: /** Getter for the name of the class realising the input structure for this operation */
056: public String getInputClassName() {
057: return mInputClassName;
058: }
059:
060: /** Getter for the full name (package and service name and name) of the class realising the input structure for this operation */
061: public String getInputClassFullName() {
062: return mInputClassFullName;
063: }
064:
065: /** Getter for the name of the proxy class to the input structure of this operation.
066: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
067: * same data but may use different datatypes depending on the nature of the technolgy.
068: * Note that this proxy class may reside in any package as chosen by generator
069: * (in fact there will most probably be more than one implementation each in different package)
070: * Also note that the name formed here is only unique inside the service (hence the word "inner" in the name.)
071: * Use getInputProxyOuterClassName() to get the "outer" class name which would somehow include the service name
072: * and therefore will be unique outside the service */
073: public String getInputProxyInnerClassName() {
074: return mInputProxyInnerClassName;
075: }
076:
077: /** Getter for the name of the proxy class to the input structure of this operation.
078: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
079: * same data but may use different datatypes depending on the nature of the technolgy.
080: * Note that this proxy class may reside in any package as chosen by generator
081: * (in fact there will most probably be more than one implementation each in different package)
082: * Also note that the name formed here is unique outside the service scope (hence the word "outer" in the name.)
083: * this means that the name somehow includes the service name and may therefore be longer than necessary
084: * if class is placed inside the service scope. Use getInputProxyInnerClassName() to get the "inner"
085: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
086: public String getInputProxyOuterClassName() {
087: return mInputProxyOuterClassName;
088: }
089:
090: /** Getter for the name of the proxy translator class between input proxy structure and input structure
091: * Note that this proxy translator class may reside in any package as chosen by generator
092: * (in fact there will most probably be more than one implementation each in different package)
093: * Also note that the name formed here is only unique inside the service (hence the word "inner" in the name.)
094: * Use getInputProxyTranslatorOuterClassName() to get the "outer" class name which would somehow include the service name
095: * and therefore will be unique outside the service */
096: public String getInputProxyTranslatorInnerClassName() {
097: return mInputProxyTranslatorInnerClassName;
098: }
099:
100: /** Getter for the name of the proxy translator class between input proxy structure and input structure
101: * Note that this proxy translator class may reside in any package as chosen by generator
102: * (in fact there will most probably be more than one implementation each in different package)
103: * Also note that the name formed here is unique outside the service scope (hence the word "outer" in the name.)
104: * this means that the name somehow includes the service name and may therefore be longer than necessary
105: * if class is placed inside the service scope. Use getInputProxyTranslatorInnerClassName() to get the "inner"
106: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
107: public String getInputProxyTranslatorOuterClassName() {
108: return mInputProxyTranslatorOuterClassName;
109: }
110:
111: /** Getter for the name of the class realising the result structure for this operation */
112: public String getResultClassName() {
113: return mResultClassName;
114: }
115:
116: /** Getter for the full name (package and service name and name) of the class realising the result structure for this operation */
117: public String getResultClassFullName() {
118: return mResultClassFullName;
119: }
120:
121: /** Getter for the name of the proxy class to the result structure of this operation.
122: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
123: * same data but may use different datatypes depending on the nature of the technolgy.
124: * Note that this proxy class may reside in any package as chosen by generator
125: * (in fact there will most probably be more than one implementation each in different package)
126: * Also note that the name formed here is only unique inside the service scope (hence the word "inner" in the name.)
127: * Use getResultProxyOuterClassName() to get the "outer" class name which would somehow include the service name
128: * and therefore will be unique outside the service scope */
129: public String getResultProxyInnerClassName() {
130: return mResultProxyInnerClassName;
131: }
132:
133: /** Getter for the name of the proxy translator class between result proxy structure and result structure
134: * Note that this proxy translator class may reside in any package as chosen by generator
135: * (in fact there will most probably be more than one implementation each in different package)
136: * Also note that the name formed here is only unique inside the service scope (hence the word "inner" in the name.)
137: * Use getResultProxyTranslatorOuterClassName() to get the "outer" class name which would somehow include the service name
138: * and therefore will be unique outside the service scope */
139: public String getResultProxyTranslatorInnerClassName() {
140: return mResultProxyTranslatorInnerClassName;
141: }
142:
143: /** Getter for the name of the proxy class to the result structure of this operation.
144: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
145: * same data but may use different datatypes depending on the nature of the technolgy.
146: * Note that this proxy class may reside in any package as chosen by generator
147: * (in fact there will most probably be more than one implementation each in different package)
148: * Also note that the name formed here is unique outside the service scope (hence the word "outer" in the name.)
149: * this means that the name somehow includes the service name and may therefore be longer than necessary
150: * if class is placed inside the service scope. Use getResultProxyInnerClassName() to get the "inner"
151: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
152: public String getResultProxyOuterClassName() {
153: return mResultProxyOuterClassName;
154: }
155:
156: /** Getter for the name of the proxy translator class between result proxy structure and result structure
157: * Note that this proxy translator class may reside in any package as chosen by generator
158: * (in fact there will most probably be more than one implementation each in different package)
159: * Also note that the name formed here is unique outside the service scope (hence the word "outer" in the name.)
160: * this means that the name somehow includes the service name and may therefore be longer than necessary
161: * if class is placed inside the service scope. Use getResultProxyTranslatorInnerClassName() to get the "inner"
162: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
163: public String getResultProxyTranslatorOuterClassName() {
164: return mResultProxyTranslatorOuterClassName;
165: }
166:
167: /** Getter for the name of the output message which should be returned if
168: * operation has detected invalid input. */
169: public String getInvalidOperationInputOperationOutputMessageName() {
170: return mInvalidOperationInputOperationOutputMessageName;
171: }
172:
173: /** Setter for the unique identifier of the corresponding operation */
174: public void setOperationRef(String pOperationRef) {
175: mOperationRef = pOperationRef;
176: }
177:
178: /** Setter for the normalised name of the element. Normalised name is a
179: * "safe to use in computing" kind of name it must be a single word consisting of
180: * the most basic set of characters (e.g. letters, numbers, underscores) */
181: public void setNormalisedName(String pNormalisedName) {
182: mNormalisedName = pNormalisedName;
183: }
184:
185: /** Setter for the name of the method realising the operation */
186: public void setMethodName(String pMethodName) {
187: mMethodName = pMethodName;
188: }
189:
190: /** Setter for the name of the class realising the input structure for this operation */
191: public void setInputClassName(String pInputClassName) {
192: mInputClassName = pInputClassName;
193: }
194:
195: /** Setter for the full name (package and service name and name) of the class realising the input structure for this operation */
196: public void setInputClassFullName(String pInputClassFullName) {
197: mInputClassFullName = pInputClassFullName;
198: }
199:
200: /** Setter for the name of the proxy class to the input structure of this operation.
201: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
202: * same data but may use different datatypes depending on the nature of the technolgy.
203: * Note that this proxy class may reside in any package as chosen by generator
204: * (in fact there will most probably be more than one implementation each in different package)
205: * Also note that the name expected here is only unique inside the service scope (hence the word "inner" in the name.)
206: * Use setInputProxyOuterClassName() to set the "outer" class name which would somehow include the service name
207: * and therefore will be unique outside the service scope */
208: public void setInputProxyInnerClassName(
209: String pInputProxyInnerClassName) {
210: mInputProxyInnerClassName = pInputProxyInnerClassName;
211: }
212:
213: /** Setter for the name of the proxy class to the input structure of this operation.
214: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
215: * same data but may use different datatypes depending on the nature of the technolgy.
216: * Note that this proxy class may reside in any package as chosen by generator
217: * (in fact there will most probably be more than one implementation each in different package)
218: * Also note that the name expected here is only unique inside the service scope (hence the word "inner" in the name.)
219: * Use setInputProxyOuterClassName() to set the "outer" class name which would somehow include the service name
220: * and therefore will be unique outside the service scope */
221: public void setInputProxyOuterClassName(
222: String pInputProxyOuterClassName) {
223: mInputProxyOuterClassName = pInputProxyOuterClassName;
224: }
225:
226: /** Setter for the name of the proxy translator class between input proxy structure and input structure
227: * Note that this proxy translator class may reside in any package as chosen by generator
228: * (in fact there will most probably be more than one implementation each in different package)
229: * Also note that the name expected here is only unique inside the service scope (hence the word "inner" in the name.)
230: * Use setInputProxyTranslatorOuterClassName() to set the "outer" class name which would somehow include the service name
231: * and therefore will be unique outside the service scope */
232: public void setInputProxyTranslatorInnerClassName(
233: String pInputProxyTranslatorInnerClassName) {
234: mInputProxyTranslatorInnerClassName = pInputProxyTranslatorInnerClassName;
235: }
236:
237: /** Setter for the name of the proxy translator class between input proxy structure and input structure
238: * Note that this proxy translator class may reside in any package as chosen by generator
239: * (in fact there will most probably be more than one implementation each in different package)
240: * Also note that the name expected here is unique outside the service scope (hence the word "outer" in the name.)
241: * this means that the name somehow includes the service name and may therefore be longer than necessary
242: * if class is placed inside the service scope. Use setInputProxyTranslatorInnerClassName() to set the "inner"
243: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
244: public void setInputProxyTranslatorOuterClassName(
245: String pInputProxyTranslatorOuterClassName) {
246: mInputProxyTranslatorOuterClassName = pInputProxyTranslatorOuterClassName;
247: }
248:
249: /** Setter for the name of the class realising the result structure for this operation */
250: public void setResultClassName(String pResultClassName) {
251: mResultClassName = pResultClassName;
252: }
253:
254: /** Setter for the full name (package and service name and name) of the class realising the result structure for this operation */
255: public void setResultClassFullName(String pResultClassFullName) {
256: mResultClassFullName = pResultClassFullName;
257: }
258:
259: /** Setter for the name of the proxy class to the result structure of this operation.
260: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
261: * same data but may use different datatypes depending on the nature of the technolgy.
262: * Note that this proxy class may reside in any package as chosen by generator
263: * (in fact there will most probably be more than one implementation each in different package)
264: * Also note that the name expected here is only unique inside the service scope (hence the word "inner" in the name.)
265: * Use setResultProxyOuterClassName() to set the "outer" class name which would somehow include the service name
266: * and therefore will be unique outside the service scope */
267: public void setResultProxyInnerClassName(
268: String pResultProxyInnerClassName) {
269: mResultProxyInnerClassName = pResultProxyInnerClassName;
270: }
271:
272: /** Setter for the name of the proxy class to the result structure of this operation.
273: * Use it to name the CORBA, RMI etc proxy structures (structures which carry the
274: * same data but may use different datatypes depending on the nature of the technolgy.
275: * Note that this proxy class may reside in any package as chosen by generator
276: * (in fact there will most probably be more than one implementation each in different package)
277: * Also note that the name expected here is unique outside the service scope (hence the word "outer" in the name.)
278: * this means that the name somehow includes the service name and may therefore be longer than necessary
279: * if class is placed inside the service scope. Use setResultProxyInnerClassName() to set the "inner"
280: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
281: public void setResultProxyOuterClassName(
282: String pResultProxyOuterClassName) {
283: mResultProxyOuterClassName = pResultProxyOuterClassName;
284: }
285:
286: /** Setter for the name of the proxy translator class between result proxy structure
287: * Note that this proxy translator class may reside in any package as chosen by generator
288: * (in fact there will most probably be more than one implementation each in different package)
289: * Also note that the name expected here is only unique inside the service scope (hence the word "inner" in the name.)
290: * Use setResultProxyTranslatorOuterClassName() to set the "outer" class name which would somehow include the service name
291: * and therefore will be unique outside the service scope */
292: public void setResultProxyTranslatorInnerClassName(
293: String pResultProxyTranslatorInnerClassName) {
294: mResultProxyTranslatorInnerClassName = pResultProxyTranslatorInnerClassName;
295: }
296:
297: /** Setter for the name of the proxy translator class between result proxy structure
298: * Note that this proxy translator class may reside in any package as chosen by generator
299: * (in fact there will most probably be more than one implementation each in different package)
300: * Also note that the name expected here is unique outside the service scope (hence the word "outer" in the name.)
301: * this means that the name somehow includes the service name and may therefore be longer than necessary
302: * if class is placed inside the service scope. Use setResultProxyTranslatorInnerClassName() to set the "inner"
303: * class name which will not include the service name and therefore will be shorter, but not unique outside the service scope. */
304: public void setResultProxyTranslatorOuterClassName(
305: String pResultProxyTranslatorOuterClassName) {
306: mResultProxyTranslatorOuterClassName = pResultProxyTranslatorOuterClassName;
307: }
308:
309: /** Setter for the name of the output message which should be returned if
310: * operation has detected invalid input. */
311: public void setInvalidOperationInputOperationOutputMessageName(
312: String pOperationOutputMessageName) {
313: mInvalidOperationInputOperationOutputMessageName = pOperationOutputMessageName;
314: }
315:
316: /** Getter for the name of the validator inner class to this structure. Use it to name the
317: * utility classes which perform validation of the operations input data. */
318: public String getInputValidatorInnerClassName() {
319: return mInputValidatorInnerClassName;
320: }
321:
322: /** Setter for the name of the validator inner class to this structure. Use it to name the
323: * utility classes which perform validation of the operations input data. */
324: public void setInputValidatorInnerClassName(
325: String pInputValidatorInnerClassName) {
326: mInputValidatorInnerClassName = pInputValidatorInnerClassName;
327: }
328:
329: /** Getter for the name of the validator outer class to this structure. Use it to name the
330: * utility classes which perform validation of the operations input data. */
331: public String getInputValidatorOuterClassName() {
332: return mInputValidatorOuterClassName;
333: }
334:
335: /** Setter for the name of the validator outer class to this structure. Use it to name the
336: * utility classes which perform validation of the operations input data. */
337: public void setInputValidatorOuterClassName(
338: String pInputValidatorOuterClassName) {
339: mInputValidatorOuterClassName = pInputValidatorOuterClassName;
340: }
341: }
|