Method: accept(GenClassClassVisitor)

1: package de.fhdw.wtf.generator.java.generatorModel;
2:
3: import java.util.HashMap;
4: import java.util.Map;
5: import java.util.Vector;
6:
7: import de.fhdw.wtf.generator.java.visitor.GenClassClassVisitor;
8: import de.fhdw.wtf.generator.java.visitor.GenClassClassVisitorException;
9: import de.fhdw.wtf.generator.java.visitor.GenClassClassVisitorReturn;
10:
11: /**
12: * Represents an external class. Such a class may not be changed by e.g. adding operations to it. It is used to link
13: * generated classes via extends to externally available classes, or to reference external classes in parameter types.
14: * This is used e.g. to generate load constructors that require a parameter of type UserObject.
15: *
16: * The class features a static getInstance() method which does a bit of bookkeeping in order to create at most one
17: * GenExternalClassClass object per external interface.
18: */
19: public class GenExternalClassClass extends GenClassClass {
20:         
21:         /**
22:          * Maps fully qualified names of external interfaces to GenExternalClassClass objects.
23:          */
24:         private static Map<String, GenExternalClassClass> extIfaceMap = new HashMap<>();
25:         
26:         /**
27:          * Creates a GenExternalClassClass object.
28:          *
29:          * @param packageName
30:          * The package name of the external interface.
31:          * @param typeName
32:          * The type name of the external interface.
33:          */
34:         protected GenExternalClassClass(final String packageName, final String typeName) {
35:                 super(typeName, new Vector<GenJavaOperation>(), new Vector<GenInterfaceClass>(),
36:                                 new Vector<GenJavaAttribute>(), new Vector<GenClassModifier>(), new Vector<GenJavaOperation>(), null,
37:                                 GenUnqualifiedPackage.create(packageName), null, null);
38:         }
39:         
40:         /**
41:          * Returns a GenExternalClassClass object for a given external Class, specified by a fully qualified name.
42:          *
43:          * @param fullyQualifiedName
44:          * The fully qualified name of an external interface.
45:          * @return The GenExternalClassClass object.
46:          */
47:         public static synchronized GenExternalClassClass getInstance(final String fullyQualifiedName) {
48:                 GenExternalClassClass iface = extIfaceMap.get(fullyQualifiedName);
49:                 if (iface == null) {
50:                         final int pos = fullyQualifiedName.lastIndexOf('.');
51:                         if (pos < 0) {
52:                                 iface = new GenExternalClassClass("", fullyQualifiedName);
53:                         } else {
54:                                 iface =
55:                                                 new GenExternalClassClass(fullyQualifiedName.substring(0, pos),
56:                                                                 fullyQualifiedName.substring(pos + 1));
57:                         }
58:                         
59:                         extIfaceMap.put(fullyQualifiedName, iface);
60:                 }
61:                 return iface;
62:         }
63:         
64:         @Override
65:         public void accept(final GenClassClassVisitor visitor) {
66:                 visitor.handle(this);
67:         }
68:         
69:         @Override
70:         public <X> X accept(final GenClassClassVisitorReturn<X> visitor) {
71:                 return visitor.handle(this);
72:         }
73:         
74:         @Override
75:         public <Y extends Exception> void accept(final GenClassClassVisitorException<Y> visitor) throws Y {
76:                 visitor.handle(this);
77:         }
78:         
79: }