Source Code Cross Referenced for STServicemoduleStylesheet.java in  » UML » MetaBoss » com » metaboss » sdlctools » services » codegenerationstylesheet » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » UML » MetaBoss » com.metaboss.sdlctools.services.codegenerationstylesheet 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


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 servicemodule */
018:        public final class STServicemoduleStylesheet {
019:            private String mServicemoduleRef;
020:            private String mNormalisedName = null;
021:            private String mNormalisedTypedName = null;
022:            private String mPackageName;
023:            private String mEventPublisherPackageName = null;
024:            private String mEventPublisherNamespaceURI = null;
025:            private String mPackageDir;
026:            private String mAdapterRootPackageName;
027:            private String mSystemSubPackageName;
028:            private String mAdapterRootPackageDir;
029:            private String mAdapterClassName = null;
030:            private String mNamespaceURI;
031:            private String mServicesGenericStringStructuresAdapterPackageName;
032:            private String mServicesGenericSimplifiedStringStructuresAdapterPackageName;
033:            private String mServicesGenericDomElementsAdapterPackageName;
034:            private String mServicesGenericXmlStringsAdapterPackageName;
035:            private String mEventPublishersGenericStringStructuresAdapterPackageName;
036:            private String mEventPublishersGenericSimplifiedStringStructuresAdapterPackageName;
037:            private String mEventPublishersGenericDomElementsAdapterPackageName;
038:            private String mEventPublishersGenericXmlStringsAdapterPackageName;
039:            private String mBusinessServicesInterfaceModuleName = null;
040:            private String mBusinessServicesImplementationModuleName = null;
041:            private String mBusinessServicesDistributionModuleName = null;
042:            private String mWebServicesServerModuleName = null;
043:            private String mGeneratedProxyRootPackageName = null;
044:            private String mGeneratedProxyRootPackageDir = null;
045:            private String mCataloguePathToTop = null;
046:            private String mCataloguePathFromTop = null;
047:
048:            /** Getter for the ref of the servicemodule */
049:            public String getServicemoduleRef() {
050:                return mServicemoduleRef;
051:            }
052:
053:            /** Getter for the normalised name of the element. Normalised name is a
054:             * "safe to use in computing" kind of name it must be a single word consisting of
055:             * the most basic set of characters (e.g. letters, numbers, underscores)
056:             * Note that this name may not be unique in the namespace of the parent element, because
057:             * sibling element of another type may have the same name. Consider using NormalisedTypedName to get more unique name  */
058:            public String getNormalisedName() {
059:                return mNormalisedName;
060:            }
061:
062:            /** Getter for the normalised typed name of the element.
063:             * Normalised typed name is similar to the normalised name, but it is derived
064:             * from type name and element name which guarantees that this name is unique within parent element scope. */
065:            public String getNormalisedTypedName() {
066:                return mNormalisedTypedName;
067:            }
068:
069:            /** Setter for the normalised typed name of the element.
070:             * Normalised typed name is similar to the normalised name, but it is derived
071:             * from type name and element name which guarantees that this name is unique within parent element scope. */
072:            public void setNormalisedTypedName(String pNormalisedTypedName) {
073:                mNormalisedTypedName = pNormalisedTypedName;
074:            }
075:
076:            /** Getter for the name of the package for the components of the servicemodule (i.e. structures and services) */
077:            public String getPackageName() {
078:                return mPackageName;
079:            }
080:
081:            /** Getter for the name of the directory for the components of the servicemodule (i.e. structures and services) */
082:            public String getPackageDir() {
083:                return mPackageDir;
084:            }
085:
086:            /** Getter for the name of the package for the adapters of the servicemodule */
087:            public String getAdaptersRootPackageName() {
088:                return mAdapterRootPackageName;
089:            }
090:
091:            /** Getter for the name of the directory for the adapters of the servicemodule.
092:             * Directory is formed similar to package, but directory separators are used intead of dots */
093:            public String getAdapterRootPackageDir() {
094:                return mAdapterRootPackageDir;
095:            }
096:
097:            /** Getter for the standard normalised strings only adapter package name.
098:             * Normalised here means that this adapter uses proper inner structures to manage the scope of operation input and output structures. */
099:            public String getServicesGenericStringStructuresAdapterPackageName() {
100:                return mServicesGenericStringStructuresAdapterPackageName;
101:            }
102:
103:            /** Getter for the simplified strings only adapter package name.
104:             * Simplified here means that this adapter uses outer structures (with concatenated service + operation names) to manage the scope of operation input and output structures. */
105:            public String getServicesGenericSimplifiedStringStructuresAdapterPackageName() {
106:                return mServicesGenericSimplifiedStringStructuresAdapterPackageName;
107:            }
108:
109:            /** Getter for the standard xml schema namespace */
110:            public String getNamespaceURI() {
111:                return mNamespaceURI;
112:            }
113:
114:            /** Getter for the standard xml adapter package name */
115:            public String getServicesGenericDomElementsAdapterPackageName() {
116:                return mServicesGenericDomElementsAdapterPackageName;
117:            }
118:
119:            /** Getter for the standard xml strings adapter package name */
120:            public String getServicesGenericXmlStringsAdapterPackageName() {
121:                return mServicesGenericXmlStringsAdapterPackageName;
122:            }
123:
124:            /** Getter for the name of the module where business service interfaces for this serviemodule are located */
125:            public String getBusinessServicesInterfaceModuleName() {
126:                return mBusinessServicesInterfaceModuleName;
127:            }
128:
129:            /** Getter for the name of the module where business service implementations for whole servicemodule are located */
130:            public String getBusinessServicesImplementationModuleName() {
131:                return mBusinessServicesImplementationModuleName;
132:            }
133:
134:            /** Getter for the name of the module where business service distribution code for servicemodule is located */
135:            public String getBusinessServicesDistributionModuleName() {
136:                return mBusinessServicesDistributionModuleName;
137:            }
138:
139:            /** Getter for the name of the module where web services server for the system are located */
140:            public String getWebServicesServerModuleName() {
141:                return mWebServicesServerModuleName;
142:            }
143:
144:            /** Getter for the name of the root package under which generated services proxies are located.
145:             * If service has the one and only one possible default proxy (very unlikely !!!) - it can go in this package itself.
146:             * All other proxies must be in the sub packages of this package.
147:             * For example if this setting equals com.metaboss.generatedproxy than the logging proxies would
148:             * be in the package  com.metaboss.generatedproxy.logging  */
149:            public String getGeneratedProxyRootPackageName() {
150:                return mGeneratedProxyRootPackageName;
151:            }
152:
153:            /** Getter for the name of the root directory under which generated services proxies are located.
154:             * If service has the one and only one possible default proxy (very unlikely !!!) - it can go in this directory itself.
155:             * All other proxies must be in the sub packages of this package.
156:             * For example if this setting equals com.metaboss.generatedproxy than the logging proxies would
157:             * be in the package  com.metaboss.generatedproxy.logging  */
158:            public String getGeneratedProxyRootPackageDir() {
159:                return mGeneratedProxyRootPackageDir;
160:            }
161:
162:            /** Getter for the relative path to the top from the catalogue where information related to this object is located.
163:             *  Catalogue is a directory tree where each node is named as <owner type>_<owner normalised name>.
164:             *  It is used for things like help files, documentation directory tree etc. */
165:            public String getCataloguePathToTop() {
166:                return mCataloguePathToTop;
167:            }
168:
169:            /** Getter for the relative path from the top to the catalogue where information related to this object is located.
170:             *  Catalogue is a directory tree where each node is named as <owner type>_<owner normalised name>.
171:             *  It is used for things like help files, documentation directory tree etc. */
172:            public String getCataloguePathFromTop() {
173:                return mCataloguePathFromTop;
174:            }
175:
176:            /** Setter for the ref of the servicemodule */
177:            public void setServicemoduleRef(String pServicemoduleRef) {
178:                mServicemoduleRef = pServicemoduleRef;
179:            }
180:
181:            /** Setter for the normalised name of the element. Normalised name is a
182:             * "safe to use in computing" kind of name it must be a single word consisting of
183:             * the most basic set of characters (e.g. letters, numbers, underscores).
184:             * Note that this name may not be unique in the namespace of the parent element, because
185:             * sibling element of another type may have the same name. Consider using NormalisedTypedName to get more unique name  */
186:            public void setNormalisedName(String pNormalisedName) {
187:                mNormalisedName = pNormalisedName;
188:            }
189:
190:            /** Setter for the name of the package for the components of the servicemodule (i.e. structures and services) */
191:            public void setPackageName(String pPackageName) {
192:                mPackageName = pPackageName;
193:            }
194:
195:            /** Setter for the name of the directory for the components of the servicemodule (i.e. structures and services) */
196:            public void setPackageDir(String pPackageDir) {
197:                mPackageDir = pPackageDir;
198:            }
199:
200:            /** Setter for the standard normalised strings only adapter package name.
201:             * Normalised here means that this adapter uses inner structures to manage the scope of operation input and output structures. */
202:            public void setServicesGenericStringStructuresAdapterPackageName(
203:                    String pServicesGenericStringStructuresAdapterPackageName) {
204:                mServicesGenericStringStructuresAdapterPackageName = pServicesGenericStringStructuresAdapterPackageName;
205:            }
206:
207:            /** Setter for the standard simplified strings only adapter package name.
208:             * Simplified here means that this adapter uses outer structures (with concatenated service + operation names) to manage the scope of operation input and output structures. */
209:            public void setServicesGenericSimplifiedStringStructuresAdapterPackageName(
210:                    String pServicesGenericSimplifiedStringStructuresAdapterPackageName) {
211:                mServicesGenericSimplifiedStringStructuresAdapterPackageName = pServicesGenericSimplifiedStringStructuresAdapterPackageName;
212:            }
213:
214:            /** Setter for the generic xml name space URI */
215:            public void setNamespaceURI(String pNamespaceURI) {
216:                mNamespaceURI = pNamespaceURI;
217:            }
218:
219:            /** Setter for the standard xml only adapter package name */
220:            public void setServicesGenericDomElementsAdapterPackageName(
221:                    String pServicesGenericDomElementsAdapterPackageName) {
222:                mServicesGenericDomElementsAdapterPackageName = pServicesGenericDomElementsAdapterPackageName;
223:            }
224:
225:            /** Setter for the standard xml strings only adapter package name */
226:            public void setServicesGenericXmlStringsAdapterPackageName(
227:                    String pServicesGenericXmlStringsAdapterPackageName) {
228:                mServicesGenericXmlStringsAdapterPackageName = pServicesGenericXmlStringsAdapterPackageName;
229:            }
230:
231:            /** Setter for the name of the package for the adapters of the servicemodule */
232:            public void setAdaptersRootPackageName(
233:                    String pAdapterRootPackageName) {
234:                mAdapterRootPackageName = pAdapterRootPackageName;
235:            }
236:
237:            /** Setter for the name of the directory for the adapters of the servicemodule 
238:             * Directory is formed similar to package, but directory separators are used intead of dots */
239:            public void setAdapterRootPackageDir(String pAdapterRootPackageDir) {
240:                mAdapterRootPackageDir = pAdapterRootPackageDir;
241:            }
242:
243:            /** Getter for the name of the class, which is an adaptor / bridge between this servicemodule
244:             * and some other technology. Note that this class may reside in any package as chosen by generator
245:             * (in fact there will most probably be more than one implementation each in different package)  */
246:            public String getAdapterClassName() {
247:                return mAdapterClassName;
248:            }
249:
250:            /** Setter for the name of the class, which is an adaptor / bridge between this servicemodule
251:             * and some other technology. Note that this class may reside in any package as chosen by generator
252:             * (in fact there will most probably be more than one implementation each in different package)  */
253:            public void setAdapterClassName(String pAdapterClassName) {
254:                mAdapterClassName = pAdapterClassName;
255:            }
256:
257:            /** Setter for the name of the module where business service interfaces for the servicemodule are located */
258:            public void setBusinessServicesInterfaceModuleName(
259:                    String pBusinessServicesInterfaceModuleName) {
260:                mBusinessServicesInterfaceModuleName = pBusinessServicesInterfaceModuleName;
261:            }
262:
263:            /** Setter for the name of the module where business service implementations for whole servicemodule are located */
264:            public void setBusinessServicesImplementationModuleName(
265:                    String pBusinessServicesImplementationModuleName) {
266:                mBusinessServicesImplementationModuleName = pBusinessServicesImplementationModuleName;
267:            }
268:
269:            /** Setter for the name of the module where business service distribution for servciemodule */
270:            public void setBusinessServicesDistributionModuleName(
271:                    String pBusinessServicesDistributionModuleName) {
272:                mBusinessServicesDistributionModuleName = pBusinessServicesDistributionModuleName;
273:            }
274:
275:            /** Setter for the name of the module where web services server for servicemodule are located */
276:            public void setWebServicesServerModuleName(
277:                    String pWebServicesServerModuleName) {
278:                mWebServicesServerModuleName = pWebServicesServerModuleName;
279:            }
280:
281:            /** Setter for the name of the root package under which generated service proxies are located.
282:             * If service has the one and only one possible default proxy (very unlikely !!!) - it can go in this package itself.
283:             * All other proxies must be in the sub packages of this package.
284:             * For example if this setting equals com.metaboss.generatedproxy than the logging proxy would
285:             * be in the package  com.metaboss.generatedproxy.logging  */
286:            public void setGeneratedProxyRootPackageName(
287:                    String pGeneratedProxyRootPackageName) {
288:                mGeneratedProxyRootPackageName = pGeneratedProxyRootPackageName;
289:            }
290:
291:            /** Setter for the name of the root directory under which generated service proxies are located.
292:             * If service has the one and only one possible default proxy (very unlikely !!!) - it can go in this package itself.
293:             * All other proxies must be in the sub packages of this package.
294:             * For example if this setting equals com.metaboss.generatedproxy than the logging proxy would
295:             * be in the package  com.metaboss.generatedproxy.logging  */
296:            public void setGeneratedProxyRootPackageDir(
297:                    String pGeneratedProxyRootPackageDir) {
298:                mGeneratedProxyRootPackageDir = pGeneratedProxyRootPackageDir;
299:            }
300:
301:            /** Setter for the relative path to the top from the catalogue where information related to this object is located.
302:             *  Catalogue is a directory tree where each node is named as <owner type>_<owner normalised name>.
303:             *  It is used for things like help files, documentation directory tree etc. */
304:            public void setCataloguePathToTop(String pCataloguePathToTop) {
305:                mCataloguePathToTop = pCataloguePathToTop;
306:            }
307:
308:            /** Setter for the relative path from the top to the catalogue where information related to this object is located
309:             *  Catalogue is a directory tree where each node is named as <owner type>_<owner normalised name>.
310:             *  It is used for things like help files, documentation directory tree etc. */
311:            public void setCataloguePathFromTop(String pCataloguePathFromTop) {
312:                mCataloguePathFromTop = pCataloguePathFromTop;
313:            }
314:
315:            /** Getter for the name of the subpackage of the system package for this servicemodule */
316:            public String getSystemSubPackageName() {
317:                return mSystemSubPackageName;
318:            }
319:
320:            /** Setter for the name of the subpackage of the system package for this servicemodule */
321:            public void setSystemSubPackageName(String pSystemSubPackageName) {
322:                mSystemSubPackageName = pSystemSubPackageName;
323:            }
324:
325:            /** Getter for the name of the package where event pipeline interfaces realising this event subscription resides */
326:            public String getEventPublisherPackageName() {
327:                return mEventPublisherPackageName;
328:            }
329:
330:            /** Setter for the name of the package where event pipeline interfaces realising this event subscription resides */
331:            public void setEventPublisherPackageName(
332:                    String pPublisherPackageName) {
333:                mEventPublisherPackageName = pPublisherPackageName;
334:            }
335:
336:            /** Getter for the xml namespace URI used for evenpublishers */
337:            public String getEventPublisherNamespaceURI() {
338:                return mEventPublisherNamespaceURI;
339:            }
340:
341:            /** Setter for the xml namespace URI used for evenpublishers */
342:            public void setEventPublisherNamespaceURI(
343:                    String pEventPublisherNamespaceURI) {
344:                mEventPublisherNamespaceURI = pEventPublisherNamespaceURI;
345:            }
346:
347:            /** Getter for the standard normalised strings only adapter package name.
348:             * Normalised here means that this adapter uses proper inner structures to manage the scope of operation input and output structures. */
349:            public String getEventPublishersGenericStringStructuresAdapterPackageName() {
350:                return mEventPublishersGenericStringStructuresAdapterPackageName;
351:            }
352:
353:            /** Setter for the standard normalised strings only adapter package name.
354:             * Normalised here means that this adapter uses inner structures to manage the scope of operation input and output structures. */
355:            public void setEventPublishersGenericStringStructuresAdapterPackageName(
356:                    String pEventPublishersGenericStringStructuresAdapterPackageName) {
357:                mEventPublishersGenericStringStructuresAdapterPackageName = pEventPublishersGenericStringStructuresAdapterPackageName;
358:            }
359:
360:            /** Getter for the simplified strings only adapter package name.
361:             * Simplified here means that this adapter uses outer structures (with concatenated service + operation names) to manage the scope of operation input and output structures. */
362:            public String getEventPublishersGenericSimplifiedStringStructuresAdapterPackageName() {
363:                return mEventPublishersGenericSimplifiedStringStructuresAdapterPackageName;
364:            }
365:
366:            /** Setter for the standard simplified strings only adapter package name.
367:             * Simplified here means that this adapter uses outer structures (with concatenated service + operation names) to manage the scope of operation input and output structures. */
368:            public void setEventPublishersGenericSimplifiedStringStructuresAdapterPackageName(
369:                    String pEventPublishersGenericSimplifiedStringStructuresAdapterPackageName) {
370:                mEventPublishersGenericSimplifiedStringStructuresAdapterPackageName = pEventPublishersGenericSimplifiedStringStructuresAdapterPackageName;
371:            }
372:
373:            /** Getter for the standard xml adapter package name */
374:            public String getEventPublishersGenericDomElementsAdapterPackageName() {
375:                return mEventPublishersGenericDomElementsAdapterPackageName;
376:            }
377:
378:            /** Setter for the standard xml only adapter package name */
379:            public void setEventPublishersGenericDomElementsAdapterPackageName(
380:                    String pEventPublishersGenericDomElementsAdapterPackageName) {
381:                mEventPublishersGenericDomElementsAdapterPackageName = pEventPublishersGenericDomElementsAdapterPackageName;
382:            }
383:
384:            /** Getter for the standard xml strings adapter package name */
385:            public String getEventPublishersGenericXmlStringsAdapterPackageName() {
386:                return mEventPublishersGenericXmlStringsAdapterPackageName;
387:            }
388:
389:            /** Setter for the standard xml strings only adapter package name */
390:            public void setEventPublishersGenericXmlStringsAdapterPackageName(
391:                    String pEventPublishersGenericXmlStringsAdapterPackageName) {
392:                mEventPublishersGenericXmlStringsAdapterPackageName = pEventPublishersGenericXmlStringsAdapterPackageName;
393:            }
394:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.