Source Code Cross Referenced for UMLProfile.java in  » UML » AndroMDA-3.2 » org » andromda » metafacades » uml » 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 » AndroMDA 3.2 » org.andromda.metafacades.uml 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


001:        package org.andromda.metafacades.uml;
002:
003:        import org.andromda.core.profile.Profile;
004:
005:        /**
006:         * Contains the common UML AndroMDA profile. That is, it contains elements "common" to all AndroMDA components (tagged
007:         * values, stereotypes, and datatypes).
008:         *
009:         * @author Chad Brandon
010:         */
011:        public class UMLProfile {
012:            /* ----------------- Stereotypes -------------------- */
013:
014:            /**
015:             * The Profile instance from which we retrieve the mapped profile names.
016:             */
017:            private static final Profile profile = Profile.instance();
018:
019:            /**
020:             * Represents a criteria search.
021:             */
022:            public static final String STEREOTYPE_CRITERIA = profile
023:                    .get("CRITERIA");
024:
025:            /**
026:             * Represents a persistent entity.
027:             */
028:            public static final String STEREOTYPE_ENTITY = profile
029:                    .get("ENTITY");
030:
031:            /**
032:             * Represents an embedded value (typically embedded with an entity as an attribute).
033:             */
034:            public static final String STEREOTYPE_EMBEDDED_VALUE = profile
035:                    .get("EMBEDDED_VALUE");
036:
037:            /**
038:             * Represents a finder method on an entity.
039:             */
040:            public static final String STEREOTYPE_FINDER_METHOD = profile
041:                    .get("FINDER_METHOD");
042:
043:            /**
044:             * Represents the primary key of an entity.
045:             */
046:            public static final String STEREOTYPE_IDENTIFIER = profile
047:                    .get("IDENTIFIER");
048:
049:            /**
050:             * If an attribute has this stereotype, it is considered unique.
051:             */
052:            public static final String STEREOTYPE_UNIQUE = profile
053:                    .get("UNIQUE");
054:
055:            /**
056:             * Represents a service.
057:             */
058:            public static final String STEREOTYPE_SERVICE = profile
059:                    .get("SERVICE");
060:
061:            /**
062:             * Represents a value object.
063:             */
064:            public static final String STEREOTYPE_VALUE_OBJECT = profile
065:                    .get("VALUE_OBJECT");
066:
067:            /**
068:             * <p/>
069:             * Represents a web service. Stereotype a class with this stereotype when you want everything on the class to be
070:             * exposed as a web service. </p>
071:             */
072:            public static final java.lang.String STEREOTYPE_WEBSERVICE = profile
073:                    .get("WEBSERVICE");
074:
075:            /**
076:             * <p/>
077:             * Stereotype an operation on a <code>service</code> if you wish to expose the operation. </p>
078:             */
079:            public static final java.lang.String STEREOTYPE_WEBSERVICE_OPERATION = profile
080:                    .get("WEBSERVICE_OPERATION");
081:
082:            /**
083:             * The base exception stereotype. If a model element is stereotyped with this (or one of its specializations), then
084:             * the exception can be generated by a cartridge and a dependency to it from an operation will add a throws clause.
085:             */
086:            public static final String STEREOTYPE_EXCEPTION = profile
087:                    .get("EXCEPTION");
088:
089:            /**
090:             * Represents an enumeration type.
091:             */
092:            public static final String STEREOTYPE_ENUMERATION = profile
093:                    .get("ENUMERATION");
094:
095:            /**
096:             * Represents exceptions thrown during normal application processing (such as business exceptions). It extends the
097:             * base exception stereotype.
098:             */
099:            public static final String STEREOTYPE_APPLICATION_EXCEPTION = profile
100:                    .get("APPLICATION_EXCEPTION");
101:
102:            /**
103:             * Represents unexpected exceptions that can occur during application processing. This that a caller isn't expected
104:             * to handle.
105:             */
106:            public static final String STEREOTYPE_UNEXPECTED_EXCEPTION = profile
107:                    .get("UNEXPECTED_EXCEPTION");
108:
109:            /**
110:             * Represents a reference to an exception model element. Model dependencies to unstereotyped exception model
111:             * elements can be stereotyped with this. This allows the user to create a custom exception class since the
112:             * exception itself will not be generated but the references to it will be (i.e. the throws clause within an
113:             * operation).
114:             */
115:            public static final String STEREOTYPE_EXCEPTION_REF = profile
116:                    .get("EXCEPTION_REF");
117:
118:            /**
119:             * Used to indicate whether or not a parameter is nullable (since parameters do <strong>NOT </strong> allow
120:             * specification of multiplicity.
121:             */
122:            public static final String STEREOTYPE_NULLABLE = profile
123:                    .get("NULLABLE");
124:
125:            /**
126:             * Represents a manageable entity.
127:             */
128:            public static final String STEREOTYPE_MANAGEABLE = profile
129:                    .get("MANAGEABLE");
130:
131:            /**
132:             * Indicates if a persistence type's property is transient.
133:             */
134:            public static final String STEREOTYPE_TRANSIENT = profile
135:                    .get("TRANSIENT");
136:
137:            /**
138:             * Represents a "front end" use case (that is a use case used to model a presentation tier or "front end").
139:             */
140:            public static final String STEREOTYPE_FRONT_END_USECASE = profile
141:                    .get("FRONT_END_USE_CASE");
142:
143:            /**
144:             * Represents a "front end" use case that is the entry point to the presentation tier.
145:             */
146:            public static final String STEREOTYPE_FRONT_END_APPLICATION = profile
147:                    .get("FRONT_END_APPLICATION");
148:
149:            /**
150:             * Represents a "front end" view (that is it can represent a JSP page, etc).
151:             */
152:            public static final String STEREOTYPE_FRONT_END_VIEW = profile
153:                    .get("FRONT_END_VIEW");
154:
155:            /**
156:             * Represents an exception on a "front-end" view.
157:             */
158:            public static final String STEREOTYPE_FRONT_END_EXCEPTION = profile
159:                    .get("FRONT_END_EXCEPTION");
160:
161:            /* ----------------- Tagged Values -------------------- */
162:
163:            /**
164:             * Represents documentation stored as a tagged value
165:             */
166:            public static final String TAGGEDVALUE_DOCUMENTATION = profile
167:                    .get("DOCUMENTATION");
168:
169:            /**
170:             * Represents a model hyperlink stored as a tagged value.
171:             */
172:            public static final String TAGGEDVALUE_MODEL_HYPERLINK = profile
173:                    .get("MODEL_HYPERLINK");
174:
175:            /**
176:             * Represents an external hyperlink (a website outside of a model).
177:             */
178:            public static final String TAGGEDVALUE_EXTERNAL_HYPERLINK = profile
179:                    .get("EXTERNAL_HYPERLINK");
180:
181:            /**
182:             * Represents the name of the schema for entity persistence.
183:             */
184:            public static final String TAGGEDVALUE_PERSISTENCE_SCHEMA = profile
185:                    .get("PERSISTENCE_SCHEMA");
186:
187:            /**
188:             * Represents a relational table name for entity persistence.
189:             */
190:            public static final String TAGGEDVALUE_PERSISTENCE_TABLE = profile
191:                    .get("PERSISTENCE_TABLE");
192:
193:            /**
194:             * Represents a relational table column name for entity persistence.
195:             */
196:            public static final String TAGGEDVALUE_PERSISTENCE_COLUMN = profile
197:                    .get("PERSISTENCE_COLUMN");
198:
199:            /**
200:             * Represents a relational table column length
201:             */
202:            public static final String TAGGEDVALUE_PERSISTENCE_COLUMN_LENGTH = profile
203:                    .get("PERSISTENCE_COLUMN_LENGTH");
204:
205:            /**
206:             * Represents a relational table column index name.
207:             */
208:            public static final String TAGGEDVALUE_PERSISTENCE_COLUMN_INDEX = profile
209:                    .get("PERSISTENCE_COLUMN_INDEX");
210:
211:            /**
212:             * Indicates if a persistence type is immutable.
213:             */
214:            public static final String TAGGEDVALUE_PERSISTENCE_IMMUTABLE = profile
215:                    .get("PERSISTENCE_IMMUTABLE");
216:
217:            /**
218:             * Used on an association end to indicate whether its owning entity should have its identifier also be the foreign
219:             * key to the related entity.
220:             */
221:            public static final String TAGGEDVALUE_PERSISTENCE_FOREIGN_IDENTIFIER = profile
222:                    .get("PERSISTENCE_FOREIGN_IDENTIFIER");
223:
224:            /**
225:             * Used on an identifier to indicate whether or not the identifier is <em>assigned</em> (meaning
226:             * that the identifier is manually assigned instead of generated.
227:             */
228:            public static final String TAGGEDVALUE_PERSISTENCE_ASSIGNED_IDENTIFIER = profile
229:                    .get("PERSISTENCE_ASSIGNED_IDENTIFIER");
230:
231:            /**
232:             * Used on an association end to denote to name of the foreign key constraint to use in the database.
233:             */
234:            public static final String TAGGEDVALUE_PERSISTENCE_FOREIGN_KEY_CONSTRAINT_NAME = profile
235:                    .get("PERSISTENCE_FOREIGN_KEY_CONSTRAINT_NAME");
236:
237:            /**
238:             * Used to assign an enumeration attribute as a member variable rather than a literal.
239:             */
240:            public static final String TAGGEDVALUE_PERSISTENCE_ENUMERATION_MEMBER_VARIABLE = profile
241:                    .get("PERSISTENCE_ENUMERATION_MEMBER_VARIABLE");
242:
243:            /**
244:             * Used on an enumeration literal to define the enumeration literal parameters.
245:             */
246:            public static final String TAGGEDVALUE_PERSISTENCE_ENUMERATION_LITERAL_PARAMETERS = profile
247:                    .get("PERSISTENCE_ENUMERATION_LITERAL_PARAMETERS");
248:
249:            /**
250:             * Used to assign the controller to the activity (when it can not be assigned explicity).
251:             */
252:            public static final String TAGGEDVALUE_PRESENTATION_CONTROLLER_USECASE = profile
253:                    .get("PRESENTATION_CONTROLLER_USECASE");
254:
255:            /**
256:             * Used to assign the table columns to a collection/array type parameter representing a table.
257:             */
258:            public static final String TAGGEDVALUE_PRESENTATION_TABLE_COLUMNS = profile
259:                    .get("PRESENTATION_TABLE_COLUMNS");
260:
261:            /**
262:             * Used to indicate whether or not a parameter should be considered a table (used when no
263:             * table columns are specified).
264:             */
265:            public static final String TAGGEDVALUE_PRESENTATION_IS_TABLE = profile
266:                    .get("PRESENTATION_IS_TABLE");
267:
268:            /**
269:             * Used to associate an activity to a use case (when it can not be assigned explicitly).
270:             */
271:            public static final String TAGGEDVALUE_PRESENTATION_USECASE_ACTIVITY = profile
272:                    .get("PRESENTATION_USECASE_ACTIVITY");
273:
274:            /**
275:             * Stores the style of a web service (document, wrapped, rpc).
276:             */
277:            public static final String TAGGEDVALUE_WEBSERVICE_STYLE = profile
278:                    .get("WEBSERVICE_STYLE");
279:
280:            /**
281:             * Stores the use of a web service (literal, encoded).
282:             */
283:            public static final String TAGGEDVALUE_WEBSERVICE_USE = profile
284:                    .get("WEBSERVICE_USE");
285:
286:            /**
287:             * Stores the provider of the web service (RPC, EJB).
288:             */
289:            public static final String TAGGEDVALUE_WEBSERVICE_PROVIDER = profile
290:                    .get("WEBSERVICE_PROVIDER");
291:
292:            /**
293:             * Stores the name of the role (if it's different than the name of the actor stereotyped as role)
294:             */
295:            public static final String TAGGEDVALUE_ROLE_NAME = profile
296:                    .get("ROLE_NAME");
297:
298:            /**
299:             * Stores the serial version UID to be used for a class. If not specified, it will be calculated
300:             * based on the class signature.
301:             *
302:             * @see org.andromda.metafacades.uml14.ClassifierFacadeLogicImpl#handleGetSerialVersionUID()
303:             */
304:            public static final String TAGGEDVALUE_SERIALVERSION_UID = profile
305:                    .get("SERIALVERSION_UID");
306:
307:            /**
308:             * The attribute to use when referencing this table from another one.
309:             */
310:            public static final String TAGGEDVALUE_MANAGEABLE_DISPLAY_NAME = profile
311:                    .get("MANAGEABLE_DISPLAY_NAME");
312:
313:            /**
314:             * The maximum number of records to load from the DB at the same time.
315:             */
316:            public static final String TAGGEDVALUE_MANAGEABLE_MAXIMUM_LIST_SIZE = profile
317:                    .get("MANAGEABLE_MAXIMUM_LIST_SIZE");
318:
319:            /**
320:             * The maximum number of records to show at the same time.
321:             */
322:            public static final String TAGGEDVALUE_MANAGEABLE_PAGE_SIZE = profile
323:                    .get("MANAGEABLE_PAGE_SIZE");
324:
325:            /**
326:             * Indicates whether or not the underlying entity keys should be resolved when referencing it.
327:             */
328:            public static final String TAGGEDVALUE_MANAGEABLE_RESOLVEABLE = profile
329:                    .get("MANAGEABLE_RESOLVEABLE");
330:
331:            /**
332:             * Indicates whether or not the underlying entity keys should be resolved when referencing it.
333:             */
334:            public static final String TAGGEDVALUE_PERSISTENCE_COLUMN_UNIQUE_GROUP = profile
335:                    .get("COLUMN_UNIQUE_GROUP");
336:
337:            /* ----------------- Data Types -------------------- */
338:
339:            /**
340:             * Used to identify object types in the model, any other type that will be identified as an object must
341:             * specialize this type.
342:             */
343:            public static final String OBJECT_TYPE_NAME = profile
344:                    .get("OBJECT_TYPE");
345:
346:            /**
347:             * Used to identify collection types in the model, any other type that will be identified as a collection must
348:             * specialize this type.
349:             */
350:            public static final String COLLECTION_TYPE_NAME = profile
351:                    .get("COLLECTION_TYPE");
352:
353:            /**
354:             * Used to identify a list type in the model, any other type that will be identified as a list must specialize this
355:             * type.
356:             */
357:            public static final String LIST_TYPE_NAME = profile
358:                    .get("LIST_TYPE");
359:
360:            /**
361:             * Used to identify a set type in the model, any other type that will be identified as a set must specialize this
362:             * type.
363:             */
364:            public static final String SET_TYPE_NAME = profile.get("SET_TYPE");
365:
366:            /**
367:             * Used to identify date types in the model, any other type that will be identified as a date must specialize this
368:             * type.
369:             */
370:            public static final String DATE_TYPE_NAME = profile
371:                    .get("DATE_TYPE");
372:
373:            /**
374:             * Used to identify time types in the model, any other type that will be identified as a time must specialize this
375:             * type.
376:             */
377:            public static final String TIME_TYPE_NAME = profile
378:                    .get("TIME_TYPE");
379:
380:            /**
381:             * Used to identify datetime types in the model.
382:             */
383:            public static final String DATETIME_TYPE_NAME = profile
384:                    .get("DATETIME_TYPE");
385:
386:            /**
387:             * Used to identify a boolean type in the model, any other type that will be identified as a boolean type must
388:             * specialize this type.
389:             */
390:            public static final String BOOLEAN_TYPE_NAME = profile
391:                    .get("BOOLEAN_TYPE");
392:
393:            /**
394:             * Used to identify a file type in the model, any other type that will be identified as a file type must specialize
395:             * this type.
396:             */
397:            public static final String FILE_TYPE_NAME = profile
398:                    .get("FILE_TYPE");
399:
400:            /**
401:             * Used to identify a Blob type in the model, any other type that will be identified as a Blob type must specialize
402:             * this type.
403:             */
404:            public static final String BLOB_TYPE_NAME = profile
405:                    .get("BLOB_TYPE");
406:
407:            /**
408:             * Used to identify a Clob type in the model, any other type that will be identified as a Clob type must specialize
409:             * this type.
410:             */
411:            public static final String CLOB_TYPE_NAME = profile
412:                    .get("CLOB_TYPE");
413:
414:            /**
415:             * Used to identify a map type in the model, any other type that will be identified as a map type must specialize
416:             * this type.
417:             */
418:            public static final String MAP_TYPE_NAME = profile.get("MAP_TYPE");
419:
420:            /**
421:             * Used to identify a string type in the model, any other type that will be identified as a string type must
422:             * specialize this type.
423:             */
424:            public static final String STRING_TYPE_NAME = profile
425:                    .get("STRING_TYPE");
426:
427:            /**
428:             * Used to identify a void type in the model, any other type that will be identified as a void type must
429:             * specialize this type.
430:             */
431:            public static final String VOID_TYPE_NAME = profile
432:                    .get("VOID_TYPE");
433:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.