/**
* オブジェクトのフィールドにデータを設定する<br>
* Integer、Float、Float[]、Stringにしか対応していない
*
* @param obj 設定対象オブジェクト
* @param fl 設定対象フィールド
* @param ty 設定対象フィールドの型
* @param data 設定データ
* @throws IllegalArgumentException
* @throws IllegalAccessException
*/
protected void dataSetter(Object obj, Field fl, Class ty, String data)
throws IllegalArgumentException, IllegalAccessException {
// Integer型のデータを設定
if (ty.toString().equals("class java.lang.Integer")) {
fl.set(obj, Integer.parseInt(data));
}
// Float型のデータを設定
if (ty.toString().equals("class java.lang.Float")) {
fl.set(obj, Float.parseFloat(data));
}
// String型のデータを設定（""の内側）
if (ty.toString().equals("class java.lang.String")) {
fl.set(obj, getDoubleQuoatString(data));
}
// Float[]型のデータを設定
if (ty.toString().equals("class [Ljava.lang.Float;")) {
String[] s;
s = data.split(" ");
Float[] f = new Float[s.length];
for (int i = 0; i < s.length; i++) {
f[i] = Float.parseFloat(s[i]);
}
fl.set(obj, f);
}
}
/**
* Create a new instance of a class using a specific constructor or log the exception if the class
* is not instanceable. This method will rethrow any exception as an unchecked {@link
* RuntimeException}.
*
* @param <T> the type of the instance to create
* @param cls the class which represents the type of the instance to create.
* @param constructor the constructor to use.
* @param args an array of the constructor arguments.
* @return a new instance of the type given on the argument by using the specified constructor.
*/
public static <T> T createInstance(Class<T> cls, Constructor constructor, Object... args) {
try {
return (T) constructor.newInstance(args);
} catch (Throwable t) {
logger.error("Could not create bean instance of class" + cls.toString(), t);
throw new RuntimeException(t);
}
}
/**
* Create a new instance of a class or log the exception if the class is not instanceable. This
* method will rethrow any exception as an unchecked {@link RuntimeException}.
*
* @param <T>
* @param cls
* @return a new instance of the type given in the argument.
*/
public static <T> T createInstance(Class<T> cls) {
try {
return cls.newInstance();
} catch (Throwable t) {
logger.error("Could not create bean instance of class " + cls.toString(), t);
throw new RuntimeException(t);
}
}
/**
* Given a map between a string and an object of unknown type, attempt to retrieve what value is
* mapped to from the specified string and validate that the actual type matches the specified
* class.
*
* @return Null if the types do not match, or the value
*/
private static Object validateAndGet(Map<String, Object> m, String s, Class<?> c)
throws MissingMappingException, UnexpectedTypeException {
Object o = m.get(s);
if (o == null) throw new MissingMappingException(s);
if (!c.isAssignableFrom(o.getClass()))
throw new UnexpectedTypeException(s, c.toString(), o.getClass().toString());
else return o;
}
public TitanGraphIndex getExternalIndex(Class<? extends Element> clazz, String backingIndex) {
String prefix;
if (Vertex.class.isAssignableFrom(clazz)) prefix = "v";
else if (Edge.class.isAssignableFrom(clazz)) prefix = "e";
else if (TitanVertexProperty.class.isAssignableFrom(clazz)) prefix = "p";
else throw new AssertionError(clazz.toString());
String indexName = prefix + backingIndex;
TitanGraphIndex index = mgmt.getGraphIndex(indexName);
if (index == null) {
index = mgmt.buildIndex(indexName, clazz).buildMixedIndex(backingIndex);
}
return index;
}
static String[] c_signature(Class c, String expr) {
if (c.isPrimitive()) return strs("j" + c.toString(), expr, expr);
if (c == Pointer.class)
return strs(
"void*",
"createPointerFromIO(env, " + expr + ", NULL)",
"getPointerPeer(env, " + expr + ")"); // TODO callIO
if (c == CLong.class)
return strs("long", "BoxCLong(env, " + expr + ")", "UnBoxCLong(env, " + expr + ")");
if (c == SizeT.class)
return strs("size_t", "BoxSizeT(env, " + expr + ")", "UnBoxSizeT(env, " + expr + ")");
if (c == TimeT.class)
return strs("time_t", "BoxTimeT(env, " + expr + ")", "UnBoxTimeT(env, " + expr + ")");
throw new UnsupportedOperationException("Cannot compute C signature for " + c.getName());
}
/**
* Binds data from reference model instance to XML binding classes
*
* @param obj
* @return
* @throws XMLBindingException
*/
public Object bindToXML(Object obj) throws XMLBindingException {
if (obj == null) {
return null;
}
String className = obj.getClass().getSimpleName();
Method[] methods = obj.getClass().getMethods();
try {
Class xmlClass = Class.forName(XML_BINDING_PACKAGE + className.toUpperCase());
// debug code only
if (xmlClass.getClasses().length != 1) {
log.debug("XMLBinding: bindToXML(): xmlClass.getClass()=" + xmlClass.getClass());
log.debug("XMLBinding: bindToXML(): xmlClass.toString()=" + xmlClass.toString());
for (Class clazz : xmlClass.getClasses()) {
log.debug("\t clazz.getClass()=" + clazz.getClass());
log.debug("\t clazz.toString()=" + clazz.toString());
}
}
Class factoryClass = xmlClass.getClasses()[0];
// ES modification: Add xmlOptions containing openehr (default) and xsi namespaces
// Method factoryMethod = factoryClass.getMethod(NEW_INSTANCE, null);
// Changed to pick the method with an XmlOptions parameter instead
Method factoryMethod = factoryClass.getMethod(NEW_INSTANCE, XmlOptions.class);
// First prameter null because it's a static method, see:
// http://java.sun.com/docs/books/tutorial/reflect/member/methodInvocation.html
// Second parameter should be the parameter of XmlObject.Factory.newInstance(XmlOptions
// options)
// see:
// http://xmlbeans.apache.org/docs/2.2.0/reference/org/apache/xmlbeans/XmlObject.Factory.html
//
// Previous code was: Object xmlObj = factoryMethod.invoke(null, null);
Object xmlObj = factoryMethod.invoke(null, xopt);
Map<String, Class> attributes = builder.retrieveAttribute(className);
Set<String> attributeNames = attributes.keySet();
Object attributeValue = null;
Method setterMethod = null;
for (Method method : methods) {
String name = method.getName();
// cause dead-loop
if ("getParent".equals(name)) {
continue; //
}
if (isGetter(name, attributeNames)) {
log.debug("getter: " + name);
if (method.getParameterTypes().length > 0) {
continue;
}
attributeValue = method.invoke(obj, null);
if (attributeValue == null) {
continue;
}
log.debug("value.class: " + attributeValue.getClass());
boolean isList = false;
if (attributeValue.getClass().isArray()) {
Object[] array = (Object[]) attributeValue;
if (array.length == 0) {
continue;
}
Object[] done = new Object[array.length];
for (int i = 0; i < array.length; i++) {
done[i] = bindToXML(array[i]);
}
attributeValue = done;
} else if (ProportionKind.class.equals(attributeValue.getClass())) {
ProportionKind kind = (ProportionKind) attributeValue;
attributeValue = BigInteger.valueOf(kind.getValue());
} else if (isOpenEHRRMClass(attributeValue)) {
attributeValue = bindToXML(attributeValue);
} else if (List.class.isAssignableFrom(attributeValue.getClass())) {
isList = true;
List list = (List) attributeValue;
log.debug("list.size: " + list.size());
String attributeName = getAttributeNameFromGetter(name);
setterMethod = findSetter(attributeName, xmlClass, isList);
Method addNew = findAddNew(attributeName, xmlClass);
log.debug("setter: " + setterMethod.getName() + ", xmlClass: " + xmlClass);
for (int i = 0, j = list.size() - 1; i <= j; i++) {
Object value = list.get(i);
Object[] array = new Object[2];
addNew.invoke(xmlObj, null);
array[0] = new Integer(i);
array[1] = bindToXML(value);
setterMethod.invoke(xmlObj, array);
log.debug("list.member value set!!!!");
}
}
if (!isList) {
String attributeName = getAttributeNameFromGetter(name);
log.debug(
"attribute: "
+ attributeName
+ ", value("
+ attributeValue
+ "), "
+ "type: "
+ attributeValue.getClass());
// TODO fix for mismatched attribute name in XSD and RM
if ("nullFlavor".equals(attributeName)) {
attributeName = "nullFlavour";
}
// skip function according to specs
if ("isMerged".equals(attributeName)) {
continue;
}
setterMethod = findSetter(attributeName, xmlClass, isList);
if (setterMethod == null) {
log.error(
"failed to find setterMethod for attribute: "
+ attributeName
+ " with type: "
+ xmlClass);
continue;
}
// special handling deals with 'real' typed
// attributes in specs but typed 'float' in xsd
String setter = setterMethod.getName();
if ("setAccuracy".equals(setter)
|| "setDenominator".equals(setter)
|| "setNumerator".equals(setter)) {
Double d = (Double) attributeValue;
attributeValue = d.floatValue();
}
log.debug(
"setter: "
+ setterMethod.getName()
+ ", xmlClass: "
+ xmlClass
+ ", attributeValue: "
+ attributeValue
+ ", attributeValue.class: "
+ attributeValue.getClass());
setterMethod.invoke(xmlObj, attributeValue);
}
}
}
return xmlObj;
} catch (Exception e) {
e.printStackTrace();
throw new XMLBindingException(
"exception caught when bind obj to " + className + ", " + e.getMessage());
}
}
public Type navigateParameterized(String name, Type[] params) throws OclTypeException {
Type ret = Basic.navigateAnyParameterized(name, params);
if (ret != null) return ret;
Method foundmethod = null;
// this is very similar to tudresden.ocl.lib.OclAnyImpl.findMethod
// if you find a bug here, its probably there as well.
// suprisingly one has not to go after interfaces since methods
// inherited from interfaces are automatically included into the
// implementing class. This does not happen for methods inherited
// from the superclass, so we have to ascend to all superclasses.
// unfortunately the above is only true for classes, getSuperclass invoked
// on an interface returns null, regardless of the interfaces extended by the
// interface. Therefore, we need to check out getInterfaces() if iclass is
// an interface
HashSet hsVisited = new HashSet();
LinkedList llToVisit = new LinkedList();
if (c.isInterface()) {
// as we're dealing with actual instances, it can be assumed that Object is
// a superclass
llToVisit.add(java.lang.Object.class);
}
classloop:
for (Class iclass = c; iclass != null; ) // iclass=iclass.getSuperclass())
{
Method[] methods = iclass.getDeclaredMethods();
methodloop:
for (int i = 0; i < methods.length; i++) {
if (!name.equals(methods[i].getName())) continue methodloop;
Class[] methodparams = methods[i].getParameterTypes();
if (params.length != methodparams.length) continue methodloop;
System.err.print("Checking method " + name + " (");
for (int j = 0; j < methodparams.length; j++) {
if (j != 0) {
System.err.print(", ");
}
System.err.print(methodparams[j]);
}
System.err.println(")");
for (int j = 0; j < params.length; j++)
if (!params[j].conformsTo(getTypeForClass(methodparams[j]))) {
System.err.println("No conformance for paramter # " + j);
continue methodloop;
}
if (foundmethod == null) foundmethod = methods[i];
else throw new OclTypeException("ambigious method " + name + " of " + c + ") queried.");
break classloop;
}
// determine classes to be visited
if (iclass.isInterface()) {
Class[] ca = iclass.getInterfaces();
for (int i = 0; i < ca.length; i++) {
if (!hsVisited.contains(ca[i])) {
llToVisit.add(ca[i]);
}
}
} else {
if (!hsVisited.contains(iclass.getSuperclass())) {
llToVisit.add(iclass.getSuperclass());
}
}
// mark current class visited
hsVisited.add(iclass);
// go to next class
if (!llToVisit.isEmpty()) {
iclass = (Class) llToVisit.remove(0);
} else {
iclass = null;
}
}
if (foundmethod == null) {
StringBuffer sb = new StringBuffer();
sb.append(c.toString() + " has no method " + name + " with parameters (");
for (int i = 0; i < params.length; i++) {
if (i != 0) sb.append(", ");
sb.append(params[i] + "/" + params[i]);
}
sb.append(")");
throw new OclTypeException(sb.toString());
}
return getTypeForClass(foundmethod.getReturnType());
}
@Override
public int compare(Class o1, Class o2) {
return o1.toString().compareTo(o2.toString());
}
private Operation parseMethod(Method method) {
Operation operation = new Operation();
RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
Class<?> responseClass = null;
List<String> produces = new ArrayList<String>();
List<String> consumes = new ArrayList<String>();
String responseContainer = null;
String operationId = method.getName();
Map<String, Property> defaultResponseHeaders = null;
Set<Map<String, Object>> customExtensions = null;
ApiOperation apiOperation = method.getAnnotation(ApiOperation.class);
if (apiOperation.hidden()) return null;
if (!"".equals(apiOperation.nickname())) operationId = apiOperation.nickname();
defaultResponseHeaders = parseResponseHeaders(apiOperation.responseHeaders());
operation.summary(apiOperation.value()).description(apiOperation.notes());
customExtensions = parseCustomExtensions(apiOperation.extensions());
if (customExtensions != null) {
for (Map<String, Object> extension : customExtensions) {
if (extension != null) {
for (Map.Entry<String, Object> map : extension.entrySet()) {
operation.setVendorExtension(
map.getKey().startsWith("x-") ? map.getKey() : "x-" + map.getKey(), map.getValue());
}
}
}
}
if (apiOperation.response() != null && !Void.class.equals(apiOperation.response()))
responseClass = apiOperation.response();
if (!"".equals(apiOperation.responseContainer()))
responseContainer = apiOperation.responseContainer();
/// security
if (apiOperation.authorizations() != null) {
List<SecurityRequirement> securities = new ArrayList<SecurityRequirement>();
for (Authorization auth : apiOperation.authorizations()) {
if (auth.value() != null && !"".equals(auth.value())) {
SecurityRequirement security = new SecurityRequirement();
security.setName(auth.value());
AuthorizationScope[] scopes = auth.scopes();
for (AuthorizationScope scope : scopes) {
if (scope.scope() != null && !"".equals(scope.scope())) {
security.addScope(scope.scope());
}
}
securities.add(security);
}
}
if (securities.size() > 0) {
for (SecurityRequirement sec : securities) operation.security(sec);
}
}
if (responseClass == null) {
// pick out response from method declaration
LOG.info("picking up response class from method " + method);
Type t = method.getGenericReturnType();
responseClass = method.getReturnType();
if (responseClass.equals(ResponseEntity.class)) {
responseClass = getGenericSubtype(method.getReturnType(), method.getGenericReturnType());
}
if (!responseClass.equals(Void.class)
&& !"void".equals(responseClass.toString())
&& responseClass.getAnnotation(Api.class) == null) {
LOG.info("reading model " + responseClass);
Map<String, Model> models = ModelConverters.getInstance().readAll(t);
}
}
if (responseClass != null
&& !responseClass.equals(Void.class)
&& !responseClass.equals(ResponseEntity.class)
&& responseClass.getAnnotation(Api.class) == null) {
if (isPrimitive(responseClass)) {
Property responseProperty = null;
Property property = ModelConverters.getInstance().readAsProperty(responseClass);
if (property != null) {
if ("list".equalsIgnoreCase(responseContainer))
responseProperty = new ArrayProperty(property);
else if ("map".equalsIgnoreCase(responseContainer))
responseProperty = new MapProperty(property);
else responseProperty = property;
operation.response(
200,
new Response()
.description("successful operation")
.schema(responseProperty)
.headers(defaultResponseHeaders));
}
} else if (!responseClass.equals(Void.class) && !"void".equals(responseClass.toString())) {
Map<String, Model> models = ModelConverters.getInstance().read(responseClass);
if (models.size() == 0) {
Property pp = ModelConverters.getInstance().readAsProperty(responseClass);
operation.response(
200,
new Response()
.description("successful operation")
.schema(pp)
.headers(defaultResponseHeaders));
}
for (String key : models.keySet()) {
Property responseProperty = null;
if ("list".equalsIgnoreCase(responseContainer))
responseProperty = new ArrayProperty(new RefProperty().asDefault(key));
else if ("map".equalsIgnoreCase(responseContainer))
responseProperty = new MapProperty(new RefProperty().asDefault(key));
else responseProperty = new RefProperty().asDefault(key);
operation.response(
200,
new Response()
.description("successful operation")
.schema(responseProperty)
.headers(defaultResponseHeaders));
swagger.model(key, models.get(key));
}
models = ModelConverters.getInstance().readAll(responseClass);
for (String key : models.keySet()) {
swagger.model(key, models.get(key));
}
}
}
operation.operationId(operationId);
if (requestMapping.produces() != null) {
for (String str : Arrays.asList(requestMapping.produces())) {
if (!produces.contains(str)) {
produces.add(str);
}
}
}
if (requestMapping.consumes() != null) {
for (String str : Arrays.asList(requestMapping.consumes())) {
if (!consumes.contains(str)) {
consumes.add(str);
}
}
}
ApiResponses responseAnnotation = method.getAnnotation(ApiResponses.class);
if (responseAnnotation != null) {
updateApiResponse(operation, responseAnnotation);
} else {
ResponseStatus responseStatus = method.getAnnotation(ResponseStatus.class);
if (responseStatus != null) {
operation.response(
responseStatus.value().value(), new Response().description(responseStatus.reason()));
}
}
boolean isDeprecated = false;
Deprecated annotation = method.getAnnotation(Deprecated.class);
if (annotation != null) isDeprecated = true;
boolean hidden = false;
if (apiOperation != null) hidden = apiOperation.hidden();
// process parameters
Class[] parameterTypes = method.getParameterTypes();
Type[] genericParameterTypes = method.getGenericParameterTypes();
Annotation[][] paramAnnotations = method.getParameterAnnotations();
// paramTypes = method.getParameterTypes
// genericParamTypes = method.getGenericParameterTypes
for (int i = 0; i < parameterTypes.length; i++) {
Type type = genericParameterTypes[i];
List<Annotation> annotations = Arrays.asList(paramAnnotations[i]);
List<Parameter> parameters = getParameters(type, annotations);
for (Parameter parameter : parameters) {
operation.parameter(parameter);
}
}
if (operation.getResponses() == null) {
operation.defaultResponse(new Response().description("successful operation"));
}
// Process @ApiImplicitParams
this.readImplicitParameters(method, operation);
return operation;
}
/**
* Generates code to convert a wrapped value type to a primitive type. Handles unwrapping
* java.lang.Boolean, and java.lang.Number types. Generates the appropriate RETURN bytecode.
*/
static void generateReturnResult(
ClassFileWriter cfw, Class<?> retType, boolean callConvertResult) {
// wrap boolean values with java.lang.Boolean, convert all other
// primitive values to java.lang.Double.
if (retType == Void.TYPE) {
cfw.add(ByteCode.POP);
cfw.add(ByteCode.RETURN);
} else if (retType == Boolean.TYPE) {
cfw.addInvoke(
ByteCode.INVOKESTATIC, "aurora/javascript/Context", "toBoolean", "(Ljava/lang/Object;)Z");
cfw.add(ByteCode.IRETURN);
} else if (retType == Character.TYPE) {
// characters are represented as strings in JavaScript.
// return the first character.
// first convert the value to a string if possible.
cfw.addInvoke(
ByteCode.INVOKESTATIC,
"aurora/javascript/Context",
"toString",
"(Ljava/lang/Object;)Ljava/lang/String;");
cfw.add(ByteCode.ICONST_0);
cfw.addInvoke(ByteCode.INVOKEVIRTUAL, "java/lang/String", "charAt", "(I)C");
cfw.add(ByteCode.IRETURN);
} else if (retType.isPrimitive()) {
cfw.addInvoke(
ByteCode.INVOKESTATIC, "aurora/javascript/Context", "toNumber", "(Ljava/lang/Object;)D");
String typeName = retType.getName();
switch (typeName.charAt(0)) {
case 'b':
case 's':
case 'i':
cfw.add(ByteCode.D2I);
cfw.add(ByteCode.IRETURN);
break;
case 'l':
cfw.add(ByteCode.D2L);
cfw.add(ByteCode.LRETURN);
break;
case 'f':
cfw.add(ByteCode.D2F);
cfw.add(ByteCode.FRETURN);
break;
case 'd':
cfw.add(ByteCode.DRETURN);
break;
default:
throw new RuntimeException("Unexpected return type " + retType.toString());
}
} else {
String retTypeStr = retType.getName();
if (callConvertResult) {
cfw.addLoadConstant(retTypeStr);
cfw.addInvoke(
ByteCode.INVOKESTATIC,
"java/lang/Class",
"forName",
"(Ljava/lang/String;)Ljava/lang/Class;");
cfw.addInvoke(
ByteCode.INVOKESTATIC,
"aurora/javascript/JavaAdapter",
"convertResult",
"(Ljava/lang/Object;" + "Ljava/lang/Class;" + ")Ljava/lang/Object;");
}
// Now cast to return type
cfw.add(ByteCode.CHECKCAST, retTypeStr);
cfw.add(ByteCode.ARETURN);
}
}
@Test
public void testToString() throws Exception {
for (Class<?> type : standardTypes) {
assertThat(describe(type).toString(), is(type.toString()));
}
}
