_class = _class.array();
private void createAndInitLocationsField() { // private String[] locations; locationsField = jClass.field(JMod.PRIVATE, ref.string().array(), "locations"); // locations = getResources().getStringArray(R.array.locations); JFieldRef rArrayLocations = ref.r().staticRef("array").ref("locations"); JInvocation getResources = JExpr.invoke("getResources"); JInvocation getStringArray = getResources.invoke("getStringArray").arg(rArrayLocations); afterViewsBody.assign(locationsField, getStringArray); }
public JClass refClass(String fullyQualifiedClassName) { int arrayCounter = 0; while (fullyQualifiedClassName.endsWith("[]")) { arrayCounter++; fullyQualifiedClassName = fullyQualifiedClassName.substring(0, fullyQualifiedClassName.length() - 2); } JClass refClass = loadedClasses.get(fullyQualifiedClassName); if (refClass == null) { refClass = codeModel.directClass(fullyQualifiedClassName); loadedClasses.put(fullyQualifiedClassName, refClass); } for (int i = 0; i < arrayCounter; i++) { refClass = refClass.array(); } return refClass; }
public JClass ref(ASTType astType){ String typeName = astType.getName(); if(astType instanceof ASTArrayType){ return ref(typeName.substring(0, typeName.length() - 2)).array(); } return ref(typeName); }
/** * Parses additional left-associative suffixes, like type arguments * and array specifiers. */ private JClass parseSuffix(JClass clazz) throws ClassNotFoundException { if(idx==s.length()) return clazz; // hit EOL char ch = s.charAt(idx); if(ch=='<') return parseSuffix(parseArguments(clazz)); if(ch=='[') { if(s.charAt(idx+1)==']') { idx+=2; return parseSuffix(clazz.array()); } throw new IllegalArgumentException("Expected ']' but found "+s.substring(idx+1)); } return clazz; }
/** * Parses additional left-associative suffixes, like type arguments * and array specifiers. */ private JClass parseSuffix(JClass clazz) throws ClassNotFoundException { if(idx==s.length()) return clazz; // hit EOL char ch = s.charAt(idx); if(ch=='<') return parseSuffix(parseArguments(clazz)); if(ch=='[') { if(s.charAt(idx+1)==']') { idx+=2; return parseSuffix(clazz.array()); } throw new IllegalArgumentException("Expected ']' but found "+s.substring(idx+1)); } return clazz; }
/** * Parses additional left-associative suffixes, like type arguments * and array specifiers. */ private JClass parseSuffix(JClass clazz) throws ClassNotFoundException { if(idx==s.length()) return clazz; // hit EOL char ch = s.charAt(idx); if(ch=='<') return parseSuffix(parseArguments(clazz)); if(ch=='[') { if(s.charAt(idx+1)==']') { idx+=2; return parseSuffix(clazz.array()); } throw new IllegalArgumentException("Expected ']' but found "+s.substring(idx+1)); } return clazz; }
/** * Parses additional left-associative suffixes, like type arguments * and array specifiers. */ private JClass parseSuffix(JClass clazz) throws ClassNotFoundException { if(idx==s.length()) return clazz; // hit EOL char ch = s.charAt(idx); if(ch=='<') return parseSuffix(parseArguments(clazz)); if(ch=='[') { if(s.charAt(idx+1)==']') { idx+=2; return parseSuffix(clazz.array()); } throw new IllegalArgumentException("Expected ']' but found "+s.substring(idx+1)); } return clazz; }
/** * Parses additional left-associative suffixes, like type arguments * and array specifiers. */ private JClass parseSuffix(JClass clazz) throws ClassNotFoundException { if(idx==s.length()) return clazz; // hit EOL char ch = s.charAt(idx); if(ch=='<') return parseSuffix(parseArguments(clazz)); if(ch=='[') { if(s.charAt(idx+1)==']') { idx+=2; return parseSuffix(clazz.array()); } throw new IllegalArgumentException("Expected ']' but found "+s.substring(idx+1)); } return clazz; }
public JClass typeMirrorToJClass(TypeMirror type, EBeanHolder holder) { if (type instanceof DeclaredType) { DeclaredType declaredType = (DeclaredType) type; String declaredTypeName = declaredType.asElement().toString(); JClass declaredClass = holder.refClass(declaredTypeName); List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); List<JClass> typeArgumentJClasses = new ArrayList<JClass>(); for (TypeMirror typeArgument : typeArguments) { typeArgumentJClasses.add(typeMirrorToJClass(typeArgument, holder)); } if (typeArgumentJClasses.size() > 0) { declaredClass = declaredClass.narrow(typeArgumentJClasses); } return declaredClass; } else if (type instanceof ArrayType) { ArrayType arrayType = (ArrayType) type; JClass refClass = typeMirrorToJClass(arrayType.getComponentType(), holder); return refClass.array(); } else { return holder.refClass(type.toString()); } }
final JDefinedClass jDefindedClass = codeModel._class(JMod.PUBLIC, "org.sand.pit", ClassType.CLASS); final JMethod jmethod = jDefindedClass.method(JMod.PUBLIC, void.class, "testMethod"); final JBlock jblock = jmethod.body(); final JExpression equalsZero = JExpr.lit(0); final JVar jvarIndex = jblock.decl(JMod.FINAL, codeModel.parseType("int"), "arrayIndex", equalsZero); final JExpression getArraySize = JExpr.lit(100); final JClass wildcardClass = codeModel.ref("java.lang.Class"); final JArray newClassArray = JExpr.newArray(wildcardClass, getArraySize); final JVar jvar = jblock.decl(JMod.FINAL, wildcardClass.array(), "parameterTypes", newClassArray); final JAssignmentTarget theArray = JExpr.ref("parameterTypes").component(jvarIndex); jblock.assign(theArray, JExpr._null());
public JMethod generate(ClassContext classContext, FieldItem fieldItem, JDefinedClass theClass) { if (processedClassesMap.keySet().contains(theClass)) { return (JMethod) processedClassesMap.get(theClass); } else { final JCodeModel codeModel = getCodeModel(classContext); final JVar $values = theClass.field(JMod.PRIVATE + JMod.STATIC, List.class, "values"); final JMethod constructor = (JMethod) theClass.constructors().next(); constructor.body()._if(JOp.eq($values, JExpr._null()))._then().assign( $values, JExpr._new(codeModel.ref(ArrayList.class))); constructor.body().invoke($values, "add").arg(JExpr._this()); final JMethod values = theClass.method(JMod.PUBLIC | JMod.STATIC, theClass.array(), "values"); values.body()._return( JExpr.cast(theClass.array(), $values.invoke("toArray").arg( JExpr.newArray(theClass, JExpr.invoke($values, "size"))))); processedClassesMap.put(theClass, values); return values; } } }
public static JType[] getBasicTypes(final JCodeModel codeModel) { final JType[] basicTypes = new JType[] { codeModel.BOOLEAN, codeModel.BOOLEAN.boxify(), codeModel.BYTE, codeModel.BYTE.boxify(), codeModel.CHAR, codeModel.CHAR.boxify(), codeModel.DOUBLE, codeModel.DOUBLE.boxify(), codeModel.FLOAT, codeModel.FLOAT.boxify(), codeModel.INT, codeModel.INT.boxify(), codeModel.LONG, codeModel.LONG.boxify(), codeModel.SHORT, codeModel.SHORT.boxify(), codeModel.ref(String.class), codeModel.ref(BigInteger.class), codeModel.ref(BigDecimal.class), codeModel.ref(java.util.Date.class), codeModel.ref(java.util.Calendar.class), codeModel.ref(java.sql.Date.class), codeModel.ref(java.sql.Time.class), codeModel.ref(java.sql.Timestamp.class), codeModel.BYTE.array(), codeModel.BYTE.boxify().array(), codeModel.CHAR.array(), codeModel.CHAR.boxify().array() } ; return basicTypes; }
public JMethod generate(ClassContext classContext, FieldItem fieldItem, JDefinedClass theClass) { if (processedClassesMap.keySet().contains(theClass)) { return (JMethod) processedClassesMap.get(theClass); } else { final JCodeModel codeModel = getCodeModel(classContext); final JVar $codes = theClass.field(JMod.PRIVATE + JMod.STATIC, List.class, "codes"); final JMethod constructor = (JMethod) theClass.constructors().next(); constructor.body()._if(JOp.eq($codes, JExpr._null()))._then().assign( $codes, JExpr._new(codeModel.ref(ArrayList.class))); constructor.body().invoke($codes, "add").arg(JExpr.ref("v")); final JMethod values = theClass.method(JMod.PUBLIC | JMod.STATIC, codeModel .ref(String.class) .array(), "codes"); values.body()._return( JExpr.cast(codeModel.ref(String.class).array(), $codes.invoke("toArray").arg( JExpr.newArray(codeModel.ref(String.class), JExpr.invoke($codes, "size"))))); processedClassesMap.put(theClass, values); return values; } } }
public JMethod generate(ClassContext classContext, FieldItem fieldItem, JDefinedClass theClass) { final JCodeModel codeModel = getCodeModel(classContext); final JClass nodeClass = codeModel.ref(Node.class); final JType nodeArrayType = nodeClass.array(); final String methodName = "create" + fieldItem.name + "Nodes"; final JMethod createNode = theClass.method(JMod.PUBLIC, nodeArrayType, methodName); final JStatement statement = (JStatement) fieldItem.visit(new CreateFieldNodeVisitor(classContext)); if (statement != null) { createNode.body().add(statement); } else { createNode.body()._return(JExpr.newArray(nodeClass, 0)); } return createNode; } }
public static JType[] getBasicTypes(final JCodeModel codeModel) { final JType[] basicTypes = new JType[] { codeModel.BOOLEAN, codeModel.BOOLEAN.boxify(), codeModel.BYTE, codeModel.BYTE.boxify(), codeModel.CHAR, codeModel.CHAR.boxify(), codeModel.DOUBLE, codeModel.DOUBLE.boxify(), codeModel.FLOAT, codeModel.FLOAT.boxify(), codeModel.INT, codeModel.INT.boxify(), codeModel.LONG, codeModel.LONG.boxify(), codeModel.SHORT, codeModel.SHORT.boxify(), codeModel.ref(String.class), codeModel.ref(BigInteger.class), codeModel.ref(BigDecimal.class), codeModel.ref(java.util.Date.class), codeModel.ref(java.util.Calendar.class), codeModel.ref(java.sql.Date.class), codeModel.ref(java.sql.Time.class), codeModel.ref(java.sql.Timestamp.class), codeModel.BYTE.array(), codeModel.BYTE.boxify().array(), codeModel.CHAR.array(), codeModel.CHAR.boxify().array() } ; return basicTypes; }
public JVar declareVectorValueSetupAndMember(DirectExpression batchName, TypedFieldId fieldId) { final ValueVectorSetup setup = new ValueVectorSetup(batchName, fieldId); final Class<?> valueVectorClass = fieldId.getIntermediateClass(); final JClass vvClass = model.ref(valueVectorClass); final JClass retClass = fieldId.isHyperReader() ? vvClass.array() : vvClass; final JVar vv = declareClassField("vv", retClass); final JBlock b = getSetupBlock(); int[] fieldIndices = fieldId.getFieldIds(); JInvocation invoke = model.ref(VectorResolver.class).staticInvoke(fieldId.isHyperReader() ? "hyper" : "simple") .arg(batchName) .arg(vvClass.dotclass()); for(int i = 0; i < fieldIndices.length; i++){ invoke.arg(JExpr.lit(fieldIndices[i])); } // we have to cast here since Janino doesn't handle generic inference well. JExpression casted = JExpr.cast(retClass, invoke); b.assign(vv, casted); vvDeclaration.put(setup, vv); return vv; }
@Override public void generate(EntityMirror entityMirror, JDefinedClass definedClass) throws Exception { ClassHolder classHolder = new ClassHolder(); classHolder.definedClass = definedClass; classHolder.entityMirror = entityMirror; classHolder.entityClass = CodeModelTypes.ref(entityMirror.getFullName()); definedClass.constructor(JMod.PRIVATE); definedClass._implements(CodeModelTypes.ENTITY_METADATA.narrow(classHolder.entityClass)); JArray propertiesArray = JExpr.newArray(CodeModelTypes.PROPERTY.narrow(CodeModelTypes.WILDCARD)); for (PropertyMirror propertyMirror : entityMirror.getProperties()) { Marshaller marshaller = marshallerRegistry.getMarshallerOrThrow(propertyMirror); JFieldVar propertyField = marshaller.createPropertyField(classHolder, propertyMirror); propertiesArray.add(propertyField); } JFieldVar propertiesField = classHolder.definedClass.field(JMod.PRIVATE | JMod.STATIC | JMod.FINAL, CodeModelTypes.PROPERTY.narrow(CodeModelTypes.WILDCARD).array(), "properties", propertiesArray); classHolder.definedClass.method(JMod.PUBLIC, CodeModelTypes.PROPERTY.narrow(CodeModelTypes.WILDCARD).array(), "getProperties") .body()._return(propertiesField); generate_setFromRawEntity(classHolder); generate_toRawEntity(classHolder); generate_migrate(classHolder); generate_utilityMethods(classHolder); }
final JFieldVar valuesField = theClass.field(JMod.PROTECTED, codeModel.ref(Object.class).array(), valuesFieldName, valuesArray); final JFieldVar valueSetField = theClass.field(JMod.PROTECTED, codeModel.ref(Set.class),