org.hl7.cql.model.GenericClassSignatureParser Maven / Gradle / Ivy
package org.hl7.cql.model;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
/**
* The GenericClassSignatureParser is a convenience class for the parsing of generic signature
* and the creation of the corresponding CQL DataTypes, namely, GenericClassType and GenericClassProfileType.
* The former is used to capture the declaration of a GenericClass such as List<T>. The latter is used to capture a new type
* such as 'IntegerList' formed by binding types to generic parameters such as List<Integer>.
*/
public class GenericClassSignatureParser {
public static final CharSequence OPEN_BRACKET = "<";
public static final CharSequence CLOSE_BRACKET = ">";
public static final String EXTENDS = "extends";
private int startPos = 0;
private int endPos = 0;
private int bracketCount = 0;
private int currentBracketPosition = 0;
private Map resolvedTypes;
/**
* A generic signature such as List<T> or a bound signature
* such as List<Person>
*/
private String genericSignature;
/**
* The base type for the class type or the profile.
*/
private String baseType;
/**
* The name of a bound type such as PersonList = List<Person>
*/
private String boundGenericTypeName;
public GenericClassSignatureParser(
String genericSignature,
String baseType,
String boundGenericTypeName,
Map resolvedTypes) {
this.genericSignature = genericSignature;
this.resolvedTypes = resolvedTypes;
this.baseType = baseType;
this.boundGenericTypeName = boundGenericTypeName;
}
public GenericClassSignatureParser(String genericSignature, Map resolvedTypes) {
this(genericSignature, null, null, resolvedTypes);
}
public String getGenericSignature() {
return genericSignature;
}
public void setGenericSignature(String genericSignature) {
this.genericSignature = genericSignature;
}
public String getBaseType() {
return baseType;
}
public void setBaseType(String baseType) {
this.baseType = baseType;
}
public String getBoundGenericTypeName() {
return boundGenericTypeName;
}
public void setBoundGenericTypeName(String boundGenericTypeName) {
this.boundGenericTypeName = boundGenericTypeName;
}
/**
* Parses a generic type declaration such as Map<K,V>.
*
* @return Generic class constructed from this definition.
*/
public ClassType parseGenericSignature() {
String genericTypeName = genericSignature;
String[] params = new String[0];
if (isValidGenericSignature()) {
genericTypeName = genericSignature.substring(0, genericSignature.indexOf('<'));
String parameters =
genericSignature.substring(genericSignature.indexOf('<') + 1, genericSignature.lastIndexOf('>'));
params = escapeNestedCommas(parameters).split(",");
}
String baseTypeName = baseType;
String[] baseTypeParameters = null;
if (baseType != null && baseType.contains("<")) {
baseTypeName = baseType.substring(0, baseType.indexOf('<'));
String baseTypeParameterString = baseType.substring(baseType.indexOf('<') + 1, baseType.lastIndexOf('>'));
baseTypeParameters = escapeNestedCommas(baseTypeParameterString).split(",");
}
DataType baseDataType = resolveTypeName(baseTypeName);
ClassType genericClassType = new ClassType(genericTypeName, baseDataType);
for (String param : params) {
TypeParameter paramType = handleParameterDeclaration(unescapeNestedCommas(param));
genericClassType.addGenericParameter(paramType);
}
if (baseTypeParameters != null) {
int index = 0;
for (String baseTypeParameter : baseTypeParameters) {
if (baseTypeParameter.length() == 1
&& genericClassType.getGenericParameterByIdentifier(baseTypeParameter) == null) {
throw new RuntimeException("Cannot resolve symbol " + baseTypeParameter);
} else {
DataType boundType = resolveTypeName(unescapeNestedCommas(baseTypeParameter));
ClassType baseTypeClass = (ClassType) baseDataType;
List baseClassFields = baseTypeClass.getElements();
String myParam =
baseTypeClass.getGenericParameters().get(index).getIdentifier();
System.out.println(boundType + " replaces param " + myParam);
for (ClassTypeElement baseClassField : baseClassFields) {
ClassTypeElement myElement = new ClassTypeElement(baseClassField.getName(), boundType);
genericClassType.addElement(myElement);
}
}
index++;
}
}
return genericClassType;
}
/**
* Method handles a generic parameter declaration such as T, or T extends MyType.
*
* @param parameterString
* @return Type parameter for this parameter for this string declaration.
*/
protected TypeParameter handleParameterDeclaration(String parameterString) {
String[] paramComponents = parameterString.split("\\s+");
if (paramComponents.length == 1) {
return new TypeParameter(
StringUtils.trim(parameterString), TypeParameter.TypeParameterConstraint.NONE, null);
} else if (paramComponents.length == 3) {
if (paramComponents[1].equalsIgnoreCase(EXTENDS)) {
return new TypeParameter(
paramComponents[0],
TypeParameter.TypeParameterConstraint.TYPE,
resolveTypeName(paramComponents[2]));
} else {
throw new RuntimeException("Invalid parameter syntax: " + parameterString);
}
} else {
throw new RuntimeException("Invalid parameter syntax: " + parameterString);
}
}
/**
* Identifies the data type for the named type. If the argument is null,
* the return type will be null.
*
* @param parameterType
* @return The parameter's type
*/
protected DataType resolveTypeName(String parameterType) {
if (isValidGenericSignature(parameterType)) {
return handleBoundType(parameterType);
} else {
if (parameterType == null) {
return null;
} else {
return resolveType(parameterType);
}
}
}
/**
* Method resolves bound type if it exists or else creates it and
* adds it to the resolved type index.
*
* @param boundGenericSignature
* @return The bound type created or resolved
*/
protected DataType handleBoundType(String boundGenericSignature) {
ClassType resolvedType = (ClassType) resolvedTypes.get(escapeNestedAngleBrackets(boundGenericSignature));
if (resolvedType != null) {
return resolvedType;
} else {
String genericTypeName = boundGenericSignature.substring(0, boundGenericSignature.indexOf('<'));
resolvedType = (ClassType) resolveType(genericTypeName);
if (resolvedType == null) {
throw new RuntimeException("Unknown type " + genericTypeName);
}
ClassType newType = new ClassType(escapeNestedAngleBrackets(boundGenericSignature), resolvedType);
String parameters = boundGenericSignature.substring(
boundGenericSignature.indexOf('<') + 1, boundGenericSignature.lastIndexOf('>'));
String[] params = escapeNestedCommas(parameters).split(",");
int index = 0;
for (String param : params) {
DataType boundParam = null;
param = unescapeNestedCommas(param);
if (isValidGenericSignature(param)) {
boundParam = handleBoundType(param);
} else {
boundParam = resolveType(param);
}
TypeParameter typeParameter =
resolvedType.getGenericParameters().get(index);
for (ClassTypeElement classTypeElement : resolvedType.getElements()) {
if (classTypeElement.getType() instanceof TypeParameter) {
if (((TypeParameter) classTypeElement.getType())
.getIdentifier()
.equalsIgnoreCase(typeParameter.getIdentifier())) {
ClassTypeElement newElement = new ClassTypeElement(classTypeElement.getName(), boundParam);
newType.addElement(newElement);
}
}
}
index++;
}
resolvedTypes.put(newType.getName(), newType);
return newType;
}
}
/**
* Returns true if the generic signature assigned to this object is well-formed.
*
* @return True if the generic signature is valid
*/
public boolean isValidGenericSignature() {
return isValidGenericSignature(genericSignature);
}
/**
* Returns true if the generic signature passed as an argument is well-formed.
*
* @param genericSignature
* @return True if the generic signature is valid
*/
public boolean isValidGenericSignature(String genericSignature) {
return areBracketsPaired(genericSignature) && closingBracketsComeAfterOpeningBrackets(genericSignature);
}
/**
* Method sets the initial state of this parser.
*/
private void initializeParser() {
startPos = genericSignature.indexOf('<');
endPos = genericSignature.lastIndexOf('>');
bracketCount = openBracketCount();
}
/**
* Counts the number of < in this signature.
*
* @return
*/
private int openBracketCount() {
return openBracketCount(genericSignature);
}
/**
* Counts the number of < in this signature.
*
* @param signatureString
* @return
*/
private int openBracketCount(String signatureString) {
int matchCount = 0;
if (signatureString != null) {
matchCount = StringUtils.countMatches(signatureString, OPEN_BRACKET);
}
return matchCount;
}
/**
* Counts the number of > in this signature.
*
* @return
*/
private int closeBracketCount() {
return closeBracketCount(genericSignature);
}
/**
* Counts the number of > in this signature.
*
* @param signatureString
* @return
*/
private int closeBracketCount(String signatureString) {
int matchCount = 0;
if (signatureString != null) {
matchCount = StringUtils.countMatches(signatureString, CLOSE_BRACKET);
}
return matchCount;
}
/**
* Method returns if the number of < matches the number of >
*
* @return
*/
private boolean areBracketsPaired() {
return areBracketsPaired(genericSignature);
}
/**
* Method returns if the number of < matches the number of >
*
* @param signatureString
* @return
*/
private boolean areBracketsPaired(String signatureString) {
boolean paired = false;
if (signatureString != null) {
int openCount = openBracketCount(signatureString);
int closeCount = closeBracketCount(signatureString);
paired = (openCount == closeCount) && (openCount > 0);
}
return paired;
}
/**
* Simple check to make sure that closing brackets come after opening brackets.
*
* @return
*/
private boolean closingBracketsComeAfterOpeningBrackets() {
return closingBracketsComeAfterOpeningBrackets(genericSignature);
}
/**
* Simple check to make sure that closing brackets come after opening brackets.
*
* @param signatureString
* @return
*/
private boolean closingBracketsComeAfterOpeningBrackets(String signatureString) {
return signatureString != null && signatureString.lastIndexOf('<') < signatureString.indexOf('>');
}
/**
* Convenience method for the parsing of nested comma-separated parameters.
* Call before unescapeNestedCommas when done processing the top level of nested parameters.
*
* @param signature
* @return
*/
private String escapeNestedCommas(String signature) {
char[] signatureCharArray = signature.toCharArray();
int openBracketCount = 0;
for (int index = 0; index < signatureCharArray.length; index++) {
char c = signatureCharArray[index];
if (c == '<') {
openBracketCount++;
} else if (c == '>') {
openBracketCount--;
} else if (c == ',' && openBracketCount > 0) {
signatureCharArray[index] = '|';
}
}
return new String(signatureCharArray);
}
/**
* Convenience method for the parsing of nested comma-separated parameters.
* Call after escapeNestedCommas when handling the top level of nested parameters.
*
* @param escapedSignature
* @return
*/
private String unescapeNestedCommas(String escapedSignature) {
return escapedSignature.replaceAll("\\|", ",");
}
/**
* Method looks up data type of typeName is index.
*
* @param typeName
* @return
*/
private DataType resolveType(String typeName) {
DataType type = resolvedTypes.get(typeName);
if (type == null) {
throw new RuntimeException("Unable to resolve " + typeName);
}
return type;
}
private String escapeNestedAngleBrackets(String genericSignature) {
return genericSignature.replaceAll("<", "[").replaceAll(">", "]");
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy