/*
* Copyright (c) 1998, 2007, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* Licensed Materials - Property of IBM
* RMI-IIOP v1.0
* Copyright IBM Corp. 1998 1999 All Rights Reserved
*
*/
package sun.rmi.rmic.iiop;
import java.util.Vector;
import java.util.Hashtable;
import java.util.Enumeration;
import java.io.IOException;
import sun.tools.java.ClassDefinition;
import sun.tools.java.ClassDeclaration;
import sun.tools.java.Identifier;
import sun.tools.java.ClassNotFound;
import sun.tools.java.CompilerError;
import sun.rmi.rmic.IndentingWriter;
import java.util.HashSet;
import com.sun.corba.se.impl.util.RepositoryId;
import sun.rmi.rmic.Names;
/**
* Type is an abstract base class for a family of types which provide
* conformance checking and name mapping as defined in the "Java to IDL
* Mapping" OMG specification. The family is composed of the following
* fixed set of types:
* <pre>
*
* +- RemoteType <-- AbstractType
* |
* +- InterfaceType <-+- SpecialInterfaceType
* +- PrimitiveType | |
* | | +- NCInterfaceType
* Type <-+- CompoundType <-|
* | | +- ValueType
* +- ArrayType | |
* +- ClassType <-----+- ImplementationType
* |
* +- SpecialClassType
* |
* +- NCClassType
*
* </pre>
* PrimitiveType represents a primitive or a void type.
* <p>
* CompoundType is an abstract base representing any non-special class
* or interface type.
* <p>
* InterfaceType is an abstract base representing any non-special
* interface type.
* <p>
* RemoteType represents any non-special interface which inherits
* from java.rmi.Remote.
* <p>
* AbstractType represents any non-special interface which does not
* inherit from java.rmi.Remote, for which all methods throw RemoteException.
* <p>
* SpecialInterfaceType represents any one of the following types:
* <pre>
* java.rmi.Remote
* java.io.Serializable
* java.io.Externalizable
* </pre>
* all of which are treated as special cases.
* <p>
* NCInterfaceType represents any non-special, non-conforming interface.
* <p>
* ClassType is an abstract base representing any non-special class
* type.
* <p>
* ValueType represents any non-special class which does inherit from
* java.io.Serializable and does not inherit from java.rmi.Remote.
* <p>
* ImplementationType represents any non-special class which implements
* one or more interfaces which inherit from java.rmi.Remote.
* <p>
* SpecialClassType represents any one of the following types:
* <pre>
* java.lang.Object
* java.lang.String
* org.omg.CORBA.Object
* </pre>
* all of which are treated as special cases. For all but CORBA.Object,
* the type must match exactly. For CORBA.Object, the type must either be
* CORBA.Object or inherit from it.
* <p>
* NCClassType represents any non-special, non-conforming class.
* <p>
* ArrayType is a wrapper for any of the other types. The getElementType()
* method can be used to get the array element type. The getArrayDimension()
* method can be used to get the array dimension.
* <p>
* <i><strong>NOTE:</strong> None of these types is multi-thread-safe</i>
* @author Bryan Atsatt
*/
public abstract class Type implements sun.rmi.rmic.iiop.Constants, ContextElement, Cloneable {
private int typeCode;
private int fullTypeCode;
private Identifier id;
private String name;
private String packageName;
private String qualifiedName;
private String idlName;
private String[] idlModuleNames;
private String qualifiedIDLName;
private String repositoryID;
private Class ourClass;
private int status = STATUS_PENDING;
protected BatchEnvironment env; // Easy access for subclasses.
protected ContextStack stack; // Easy access for subclasses.
protected boolean destroyed = false;
//_____________________________________________________________________
// Public Interfaces
//_____________________________________________________________________
/**
* Return the unqualified name for this type (e.g. com.acme.Dynamite would
* return "Dynamite").
*/
public String getName() {
return name;
}
/**
* Return the package of this type (e.g. com.acme.Dynamite would
* return "com.acme"). Will return null if default package or
* if this type is a primitive.
*/
public String getPackageName() {
return packageName;
}
/**
* Return the fully qualified name of this type (e.g. com.acme.Dynamite
* would return "com.acme.Dynamite")
*/
public String getQualifiedName() {
return qualifiedName;
}
/**
* Return signature for this type (e.g. com.acme.Dynamite
* would return "com.acme.Dynamite", byte = "B")
*/
public abstract String getSignature();
/**
* IDL_Naming
* Return the unqualified IDL name of this type (e.g. com.acme.Dynamite would
* return "Dynamite").
*/
public String getIDLName() {
return idlName;
}
/**
* IDL_Naming
* Return the IDL module name for this type (e.g. com.acme.Dynamite would return
* a three element array of {"com","acme"). May be a zero length array if
* there is no module name.
*/
public String[] getIDLModuleNames() {
return idlModuleNames;
}
/**
* IDL_Naming
* Return the fully qualified IDL name for this type (e.g. com.acme.Dynamite would
* return "com::acme::Dynamite").
* @param global If true, prepends "::".
*/
public String getQualifiedIDLName(boolean global) {
if (global && getIDLModuleNames().length > 0) {
return IDL_NAME_SEPARATOR + qualifiedIDLName;
} else {
return qualifiedIDLName;
}
}
/**
* Return the identifier for this type. May be qualified.
*/
public Identifier getIdentifier() {
return id;
}
/**
* Return the repository ID for this type.
*/
public String getRepositoryID() {
return repositoryID;
}
/**
* Return the repository ID for this "boxed" type.
*/
public String getBoxedRepositoryID() {
return RepositoryId.createForJavaType(ourClass);
}
/**
* Return the Class for this type.
*/
public Class getClassInstance() {
if (ourClass == null) {
initClass();
}
return ourClass;
}
/**
* Return the status of this type.
*/
public int getStatus() {
return status;
}
/**
* Set the status of this type.
*/
public void setStatus(int status) {
this.status = status;
}
/**
* Return the compiler environment for this type.
*/
public BatchEnvironment getEnv() {
return env;
}
/**
* Get type code, without modifiers. Type codes are defined in sun.rmi.rmic.iiop.Constants.
*/
public int getTypeCode() {
return typeCode;
}
/**
* Get type code, with modifiers. Type codes are defined in sun.rmi.rmic.iiop.Constants.
*/
public int getFullTypeCode() {
return fullTypeCode;
}
/**
* Get type code modifiers. Type codes are defined in sun.rmi.rmic.iiop.Constants.
*/
public int getTypeCodeModifiers() {
return fullTypeCode & TM_MASK;
}
/**
* Check for a certain type. Type codes are defined in sun.rmi.rmic.iiop.Constants.
* Returns true if all of the bits in typeCodeMask are present in the full type code
* of this object.
*/
public boolean isType(int typeCodeMask) {
return (fullTypeCode & typeCodeMask) == typeCodeMask;
}
/**
* Like isType(), but returns true if <em>any</em> of the bits in typeCodeMask are
* present in the full type code of this object.
*/
public boolean typeMatches(int typeCodeMask) {
return (fullTypeCode & typeCodeMask) > 0;
}
/**
* Return the fullTypeCode. If an array, returns the
* type code from the element type.
*/
public int getRootTypeCode() {
if (isArray()) {
return getElementType().getFullTypeCode();
} else {
return fullTypeCode;
}
}
/**
* Return true if this type is-a InterfaceType.
*/
public boolean isInterface() {
return (fullTypeCode & TM_INTERFACE) == TM_INTERFACE;
}
/**
* Return true if this type is-a ClassType.
*/
public boolean isClass() {
return (fullTypeCode & TM_CLASS) == TM_CLASS;
}
/**
* Return true if this type is-a inner class or interface.
*/
public boolean isInner() {
return (fullTypeCode & TM_INNER) == TM_INNER;
}
/**
* Return true if this type is-a SpecialInterfaceType.
*/
public boolean isSpecialInterface() {
return (fullTypeCode & TM_SPECIAL_INTERFACE) == TM_SPECIAL_INTERFACE;
}
/**
* Return true if this type is-a SpecialClassType.
*/
public boolean isSpecialClass() {
return (fullTypeCode & TM_SPECIAL_CLASS) == TM_SPECIAL_CLASS;
}
/**
* Return true if this type is-a CompoundType.
*/
public boolean isCompound() {
return (fullTypeCode & TM_COMPOUND) == TM_COMPOUND;
}
/**
* Return true if this type is-a PrimitiveType.
*/
public boolean isPrimitive() {
return (fullTypeCode & TM_PRIMITIVE) == TM_PRIMITIVE;
}
/**
* Return true if this type is-a ArrayType.
*/
public boolean isArray() {
return (fullTypeCode & TYPE_ARRAY) == TYPE_ARRAY;
}
/**
* Return true if this type is a conforming type.
*/
public boolean isConforming() {
return (fullTypeCode & TM_NON_CONFORMING) == TM_NON_CONFORMING;
}
/**
* Return a string representation of this type.
*/
public String toString () {
return getQualifiedName();
}
/**
* Get element type. Returns null if not an array.
*/
public Type getElementType () {
return null;
}
/**
* Get array dimension. Returns zero if not an array.
*/
public int getArrayDimension () {
return 0;
}
/**
* Get brackets string. Returns "" if not an array.
*/
public String getArrayBrackets () {
return "";
}
/**
* Equality check based on the string representation.
*/
public boolean equals(Object obj) {
String us = toString();
String them = ((Type)obj).toString();
return us.equals(them);
}
/**
* Collect all the matching types referenced directly or indirectly
* by this type, including itself.
* @param typeCodeFilter The typeCode to use as a filter.
*/
public Type[] collectMatching (int typeCodeFilter) {
return collectMatching(typeCodeFilter,new HashSet(env.allTypes.size()));
}
/**
* Collect all the matching types referenced directly or indirectly
* by this type, including itself.
* @param typeCodeFilter The typeCode to use as a filter.
* @param alreadyChecked Contains types which have previously been checked
* and will be ignored. Updated during collection.
*/
public Type[] collectMatching (int typeCodeFilter, HashSet alreadyChecked) {
Vector matching = new Vector();
// Fill up the list...
addTypes(typeCodeFilter,alreadyChecked,matching);
// Copy vector contents to array and return it...
Type[] result = new Type[matching.size()];
matching.copyInto(result);
return result;
}
/**
* Return a string describing this type.
*/
public abstract String getTypeDescription ();
/**
* Return the name of this type. For arrays, will include "[]" if useIDLNames == false.
* @param useQualifiedNames If true, print qualified names; otherwise, print unqualified names.
* @param useIDLNames If true, print IDL names; otherwise, print java names.
* @param globalIDLNames If true and useIDLNames true, prepends "::".
*/
public String getTypeName ( boolean useQualifiedNames,
boolean useIDLNames,
boolean globalIDLNames) {
if (useIDLNames) {
if (useQualifiedNames) {
return getQualifiedIDLName(globalIDLNames);
} else {
return getIDLName();
}
} else {
if (useQualifiedNames) {
return getQualifiedName();
} else {
return getName();
}
}
}
/**
* Print all types referenced directly or indirectly by this type which
* match the filter.
* @param writer The stream to print to.
* @param typeCodeFilter The type codes to print.
* @param useQualifiedNames If true, print qualified names; otherwise, print unqualified names.
* @param useIDLNames If true, print IDL names; otherwise, print java names.
* @param globalIDLNames If true and useIDLNames true, prepends "::".
*/
public void print ( IndentingWriter writer,
int typeCodeFilter,
boolean useQualifiedNames,
boolean useIDLNames,
boolean globalIDLNames) throws IOException {
Type[] theTypes = collectMatching(typeCodeFilter);
print(writer,theTypes,useQualifiedNames,useIDLNames,globalIDLNames);
}
/**
* Print an array of types.
* @param writer The stream to print to.
* @param theTypes The types to print.
* @param useQualifiedNames If true, print qualified names; otherwise, print unqualified names.
* @param useIDLNames If true, print IDL names; otherwise, print java names.
* @param globalIDLNames If true and useIDLNames true, prepends "::".
*/
public static void print ( IndentingWriter writer,
Type[] theTypes,
boolean useQualifiedNames,
boolean useIDLNames,
boolean globalIDLNames) throws IOException {
for (int i = 0; i < theTypes.length; i++) {
theTypes[i].println(writer,useQualifiedNames,useIDLNames,globalIDLNames);
}
}
/**
* Print this type.
* @param writer The stream to print to.
* @param useQualifiedNames If true, print qualified names; otherwise, print unqualified names.
* @param useIDLNames If true, print IDL names; otherwise, print java names.
* @param globalIDLNames If true and useIDLNames true, prepends "::".
*/
public void print ( IndentingWriter writer,
boolean useQualifiedNames,
boolean useIDLNames,
boolean globalIDLNames) throws IOException {
printTypeName(writer,useQualifiedNames,useIDLNames,globalIDLNames);
}
/**
* Print this type, followed by a newline.
* @param writer The stream to print to.
* @param useQualifiedNames If true, print qualified names; otherwise, print unqualified names.
* @param useIDLNames If true, print IDL names; otherwise, print java names.
* @param globalIDLNames If true and useIDLNames true, prepends "::".
*/
public void println ( IndentingWriter writer,
boolean useQualifiedNames,
boolean useIDLNames,
boolean globalIDLNames) throws IOException {
print(writer,useQualifiedNames,useIDLNames,globalIDLNames);
writer.pln();
}
/**
* Print the name of this type.
* @param writer The stream to print to.
* @param useQualifiedNames If true, print qualified names; otherwise, print unqualified names.
* @param useIDLNames If true, print IDL names; otherwise, print java names.
* @param globalIDLNames If true and useIDLNames true, prepends "::".
*/
public void printTypeName ( IndentingWriter writer,
boolean useQualifiedNames,
boolean useIDLNames,
boolean globalIDLNames) throws IOException {
writer.p(getTypeName(useQualifiedNames,useIDLNames,globalIDLNames));
}
/**
* Return context element name.
*/
public String getElementName() {
return getQualifiedName();
}
//_____________________________________________________________________
// Subclass Interfaces
//_____________________________________________________________________
/**
* Print the "opening" of the package or module of this type.
* @param writer The stream to print to.
* @param useIDLNames If true, print IDL names; otherwise, print java names.
*/
protected void printPackageOpen ( IndentingWriter writer,
boolean useIDLNames) throws IOException {
if (useIDLNames) {
String[] moduleNames = getIDLModuleNames();
for (int i = 0; i < moduleNames.length; i++ ) {
writer.plnI("module " + moduleNames[i] + " {");
}
} else {
String packageName = getPackageName();
if (packageName != null) {
writer.pln("package " + packageName + ";");
}
}
}
/**
* Get a type out of the table.
*/
protected static Type getType (sun.tools.java.Type key, ContextStack stack) {
return getType(key.toString(),stack);
}
/**
* Get a type out of the table.
*/
protected static Type getType (String key, ContextStack stack) {
Type result = (Type) stack.getEnv().allTypes.get(key);
if (result != null) {
stack.traceExistingType(result);
}
return result;
}
/**
* Remove a type from the table.
*/
protected static void removeType (String key, ContextStack stack) {
Type value = (Type) stack.getEnv().allTypes.remove(key);
stack.getEnv().invalidTypes.put(value,key);
}
/**
* Remove a type from the table.
*/
protected static void removeType (sun.tools.java.Type key, ContextStack stack) {
String theKey = key.toString();
Type old = (Type) stack.getEnv().allTypes.remove(theKey);
putInvalidType(old,theKey,stack);
}
/**
* Put a type into the table.
*/
protected static void putType (sun.tools.java.Type key, Type value, ContextStack stack) {
stack.getEnv().allTypes.put(key.toString(),value);
}
/**
* Put a type into the table.
*/
protected static void putType (String key, Type value, ContextStack stack) {
stack.getEnv().allTypes.put(key,value);
}
/**
* Put an invalid type into the.
*/
protected static void putInvalidType (Type key, String value, ContextStack stack) {
stack.getEnv().invalidTypes.put(key,value);
}
/**
* Remove all invalid types...
*/
public void removeInvalidTypes () {
if (env.invalidTypes.size() > 0) {
env.invalidTypes.clear();
}
}
/**
* Walk all types and tell them to update invalid types...
*/
protected static void updateAllInvalidTypes (ContextStack stack) {
BatchEnvironment env = stack.getEnv();
if (env.invalidTypes.size() > 0) {
// Walk all types and swap invalid...
for (Enumeration e = env.allTypes.elements() ; e.hasMoreElements() ;) {
Type it = (Type) e.nextElement();
it.swapInvalidTypes();
}
// Delete all invalidTypes...
env.invalidTypes.clear();
}
}
/**
* Return count of previously parsed types.
*/
protected int countTypes () {
return env.allTypes.size();
}
/**
* Reset types removes all previously parsed types.
*/
void resetTypes () {
env.reset();
}
/**
* Release all resources.
*/
protected void destroy () {
if (!destroyed) {
id = null;
name = null;
packageName = null;
qualifiedName = null;
idlName = null;
idlModuleNames = null;
qualifiedIDLName = null;
repositoryID = null;
ourClass = null;
env = null;
stack = null;
destroyed = true;
}
}
/**
* Convert all invalid types to valid ones.
*/
protected void swapInvalidTypes () {
}
/**
* Convert an invalid type to a valid one.
*/
protected Type getValidType (Type invalidType) {
if (invalidType.getStatus() == STATUS_VALID) {
return invalidType;
}
String key = (String)env.invalidTypes.get(invalidType);
Type result = null;
if (key != null) {
result = (Type) env.allTypes.get(key);
}
if (result == null) {
throw new Error("Failed to find valid type to swap for " + invalidType + " mis-identified as " + invalidType.getTypeDescription());
}
//System.out.println("Swapped " + result + " from " + invalidType.getTypeDescription()
// + " to " + result.getTypeDescription());
//ContextStack.dumpCallStack();
return result;
}
/**
* Print the "closing" of the package or module of this type.
* @param writer The stream to print to.
* @param useIDLNames If true, print IDL names; otherwise, print java names.
*/
protected void printPackageClose ( IndentingWriter writer,
boolean useIDLNames) throws IOException {
if (useIDLNames) {
String[] moduleNames = getIDLModuleNames();
for (int i = 0; i < moduleNames.length; i++ ) {
writer.pOln("};");
}
}
}
/**
* Create a Type instance for the given type. Requires that
* setName(Identifier) be called afterward.
*/
protected Type(ContextStack stack, int fullTypeCode) {
this.env = stack.getEnv();
this.stack = stack;
this.fullTypeCode = fullTypeCode;
typeCode = fullTypeCode & TYPE_MASK;
}
/**
* Set type codes. May only be called during initialization.
*/
protected void setTypeCode(int fullTypeCode) {
this.fullTypeCode = fullTypeCode;
typeCode = fullTypeCode & TYPE_MASK;
}
/**
* Set name and package. May only be called during initialization.
*/
protected void setNames(Identifier id, String[] idlModuleNames, String idlName) {
this.id = id;
name = Names.mangleClass(id).getName().toString();
packageName = null;
if (id.isQualified()) {
packageName = id.getQualifier().toString();
qualifiedName = packageName + NAME_SEPARATOR + name;
} else {
qualifiedName = name;
}
setIDLNames(idlModuleNames,idlName);
}
/**
* Set IDL name. May only be called during initialization.
*/
protected void setIDLNames(String[] idlModuleNames, String idlName) {
this.idlName = idlName;
if (idlModuleNames != null) {
this.idlModuleNames = idlModuleNames;
} else {
this.idlModuleNames = new String[0];
}
qualifiedIDLName = IDLNames.getQualifiedName(idlModuleNames,idlName);
}
/**
* Report a ClassNotFoundException thru the compiler environment.
*/
protected static void classNotFound(ContextStack stack,
ClassNotFound e) {
classNotFound(false,stack,e);
}
/**
* Report a ClassNotFoundException thru the compiler environment.
*/
protected static void classNotFound(boolean quiet,
ContextStack stack,
ClassNotFound e) {
if (!quiet) stack.getEnv().error(0, "rmic.class.not.found", e.name);
stack.traceCallStack();
}
/**
* Report a constraint failure thru the compiler environment.
* @param constraintNum Used to generate a key of the form
"rmic.iiop.constraint.N", which must identify a message
in the "rmic.properties" file.
* @param quiet True if should not cause failure or message.
* @param stack The context stack.
* @param arg0 An object to substitute for {0} in the message.
* @param arg1 An object to substitute for {1} in the message.
* @param arg2 An object to substitute for {2} in the message.
* @return false.
*/
protected static boolean failedConstraint(int constraintNum,
boolean quiet,
ContextStack stack,
Object arg0, Object arg1, Object arg2) {
String message = "rmic.iiop.constraint." + constraintNum;
if (!quiet) {
stack.getEnv().error(0,message,
(arg0 != null ? arg0.toString() : null),
(arg1 != null ? arg1.toString() : null),
(arg2 != null ? arg2.toString() : null));
} else {
String error = stack.getEnv().errorString(message,arg0,arg1,arg2);
stack.traceln(error);
}
return false;
}
/**
* Report a constraint failure thru the compiler environment.
* @param constraintNum Used to generate a key of the form
"rmic.iiop.constraint.N", which must identify a message
in the "rmic.properties" file.
* @param quiet True if should not cause failure or message.
* @param stack The context stack.
* @param arg0 An object to substitute for {0} in the message.
* @param arg1 An object to substitute for {1} in the message.
* @return false.
*/
protected static boolean failedConstraint(int constraintNum,
boolean quiet,
ContextStack stack,
Object arg0, Object arg1) {
return failedConstraint(constraintNum,quiet,stack,arg0,arg1,null);
}
/**
* Report a constraint failure thru the compiler environment.
* @param constraintNum Used to generate a key of the form
"rmic.iiop.constraint.N", which must identify a message
in the "rmic.properties" file.
* @param quiet True if should not cause failure or message.
* @param stack The context stack.
* @param arg0 An object to substitute for {0} in the message.
* @return false.
*/
protected static boolean failedConstraint(int constraintNum,
boolean quiet,
ContextStack stack,
Object arg0) {
return failedConstraint(constraintNum,quiet,stack,arg0,null,null);
}
/**
* Report a constraint failure thru the compiler environment.
* @param quiet True if should not cause failure or message.
* @param stack The context stack.
* @param constraintNum Used to generate a key of the form
"rmic.iiop.constraint.N", which must identify a message
in the "rmic.properties" file.
* @return false.
*/
protected static boolean failedConstraint(int constraintNum,
boolean quiet,
ContextStack stack) {
return failedConstraint(constraintNum,quiet,stack,null,null,null);
}
/**
* Cloning is supported by returning a shallow copy of this object.
*/
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
throw new Error("clone failed");
}
}
/*
* Add matching types to list. Return true if this type has not
* been previously checked, false otherwise.
*/
protected boolean addTypes (int typeCodeFilter,
HashSet checked,
Vector matching) {
boolean result;
// Have we already checked this type?
if (checked.contains(this)) {
// Yes, so return false.
result = false;
} else {
// Nope, so add it...
checked.add(this);
// Do we match the filter?
if (typeMatches(typeCodeFilter)) {
// Yep. so add it and set result to true...
matching.addElement(this);
}
// Return true.
result = true;
}
return result;
}
/*
* Load a Class instance. Return null if fail.
*/
protected abstract Class loadClass();
private boolean initClass() {
if (ourClass == null) {
ourClass = loadClass();
if (ourClass == null) {
failedConstraint(27,false,stack,getQualifiedName());
return false;
}
}
return true;
}
/*
* Set the clz and repositoryID fields. Reports error
* and returns false if fails, returns true if succeeds.
*/
protected boolean setRepositoryID() {
// First, load the class...
if (!initClass()) {
return false;
}
// Now make the repositoryID and return success...
repositoryID = RepositoryId.createForAnyType(ourClass);
return true;
}
//_____________________________________________________________________
// Internal Interfaces
//_____________________________________________________________________
private Type () {} // Disallowed.
}