JFieldRef getOrAddNotFoundVar(JDefinedClass jclass) { jclass.field(PROTECTED | STATIC | FINAL, Object.class, NOT_FOUND_VALUE_FIELD, _new(jclass.owner()._ref(Object.class))); return jclass.staticRef(NOT_FOUND_VALUE_FIELD); }
private JFieldRef createUriParamConstants(final JDefinedClass builder, final String uriParamName) { return builder.staticRef(uriParamName); }
public void get(JBlock block, JVar variable) { block.assign(variable, ConstantPropertyOutline.this.referenceClass .staticRef(ConstantPropertyOutline.this.field)); }
JExpression activityRef = holder.generatedClass.staticRef("this"); JInvocation onResultInvocation = onActivityResultCase.invoke(activityRef, methodName);
private void createTypeGetter(JCodeModel model, TypeInfo pair) { JClass setClass = model.ref(Set.class); JClass uriSetClass = setClass.narrow(URI.class); JDefinedClass dc = pair.implClass; JFieldRef typeRef = pair.interfaceClass.staticRef("TYPE"); JMethod method = dc.method(JMod.PUBLIC, URI.class, "getType"); method.body()._return(typeRef); JFieldRef typeSetField = pair.interfaceClass.staticRef("TYPES"); dc.method(JMod.PUBLIC, uriSetClass, "getAllTypes") .body()._return(typeSetField); }
JFieldRef getOrAddNotFoundVar(JDefinedClass jclass) { jclass.field(PROTECTED | STATIC | FINAL, Object.class, NOT_FOUND_VALUE_FIELD, _new(jclass.owner()._ref(Object.class))); return jclass.staticRef(NOT_FOUND_VALUE_FIELD); }
public JFieldRef getAdapter(Class adapterType) { String adapterId = adapterType.getName(); JFieldRef ref = adapters.get(adapterId); if (ref == null) { final String fieldName = decapitalize(adapterType.getSimpleName()) + "Adapter"; final JPackage jPackage = jaxbObjectClass.getPackage(); final JDefinedClass definedClass; if (jPackage._getClass("Adapters") != null) { definedClass = jPackage._getClass("Adapters"); if (!definedClass.fields().containsKey(fieldName)) { JClass jClass = builderContext.toJClass(adapterType); definedClass.field(JMod.PUBLIC | JMod.STATIC | JMod.FINAL, jClass, fieldName, JExpr._new(jClass)); } } else { try { definedClass = jPackage._class("Adapters"); JClass jClass = builderContext.toJClass(adapterType); definedClass.field(JMod.PUBLIC | JMod.STATIC | JMod.FINAL, jClass, fieldName, JExpr._new(jClass)); } catch (JClassAlreadyExistsException e) { throw new IllegalStateException(e); } } ref = definedClass.staticRef(fieldName); adapters.put(adapterId, ref); } return ref; }
JFieldRef typeField = typeInfo.interfaceClass.staticRef("TYPE"); JFieldRef thingTypeField = owlThing.interfaceClass.staticRef("TYPE"); init = init.invoke("append").arg(thingTypeField); } else { for (TypeInfo superType : superList) { JFieldRef superTypeField = superType.interfaceClass.staticRef("TYPES"); init = init.invoke("appendAll").arg(superTypeField);
JExpression activityRef = holder.generatedClass.staticRef("this"); textChangeCall = methodBody.invoke(activityRef, methodName);
@Override public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { String methodName = element.getSimpleName().toString(); List<JFieldRef> idsRefs = helper.extractAnnotationFieldRefs(holder, element, Res.ID, true); for (JFieldRef idRef : idsRefs) { OnSeekBarChangeListenerHolder onSeekBarChangeListenerHolder = helper.getOrCreateListener(codeModel, holder, idRef); JInvocation textChangeCall; JMethod methodToCall = getMethodToCall(onSeekBarChangeListenerHolder); JBlock previousBody = codeModelHelper.removeBody(methodToCall); JBlock methodBody = methodToCall.body(); methodBody.add(previousBody); JExpression activityRef = holder.generatedClass.staticRef("this"); textChangeCall = methodBody.invoke(activityRef, methodName); ExecutableElement executableElement = (ExecutableElement) element; List<? extends VariableElement> parameters = executableElement.getParameters(); if (parameters.size() == 1) { JVar progressParameter = codeModelHelper.findParameterByName(methodToCall, "seekBar"); textChangeCall.arg(progressParameter); } } }
public void callSuperMethod(JMethod superMethod, EBeanHolder holder, JBlock callBlock) { JExpression activitySuper = holder.generatedClass.staticRef("super"); JInvocation superCall = JExpr.invoke(activitySuper, superMethod); for (JVar param : superMethod.params()) { superCall.arg(param); } JType returnType = superMethod.type(); if (returnType.fullName().equals("void")) { callBlock.add(superCall); } else { callBlock._return(superCall); } }
body._return(definedClass.staticRef(COMPLEX_TYPE_FIELD_NAME));
JExpression activityRef = holder.generatedClass.staticRef("this"); JInvocation call = JExpr.invoke(activityRef, methodName);
@Override public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { Classes classes = holder.classes(); String methodName = element.getSimpleName().toString(); ExecutableElement executableElement = (ExecutableElement) element; List<? extends VariableElement> parameters = executableElement.getParameters(); boolean hasViewParameter = parameters.size() == 1; List<JFieldRef> idsRefs = helper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(Res.ID), true); JDefinedClass onClickListenerClass = codeModel.anonymousClass(classes.VIEW_ON_CLICK_LISTENER); JMethod onClickMethod = onClickListenerClass.method(JMod.PUBLIC, codeModel.VOID, "onClick"); onClickMethod.annotate(Override.class); JVar onClickViewParam = onClickMethod.param(classes.VIEW, "view"); JExpression activityRef = holder.generatedClass.staticRef("this"); JInvocation clickCall = onClickMethod.body().invoke(activityRef, methodName); if (hasViewParameter) { clickCall.arg(onClickViewParam); } for (JFieldRef idRef : idsRefs) { JBlock block = holder.afterSetContentView.body().block(); JInvocation findViewById = invoke("findViewById"); JVar view = block.decl(classes.VIEW, "view", findViewById.arg(idRef)); block._if(view.ne(_null()))._then().invoke(view, "setOnClickListener").arg(_new(onClickListenerClass)); } }
private void renderClassLevelAnnotations(JDefinedClass classModel, List<FieldModel> fields) throws Exception { JFieldRef constantsClass = classModel.staticRef(Util.CONSTANTS_CLASS_NAME); JFieldRef elementsClass = classModel.staticRef(Util.ELEMENTS_CLASS_NAME); JClass coreConstants = codeModel.ref(CoreConstants.class); JFieldRef commonElementsRef = coreConstants.staticRef("CommonElements"); // XmlRootElement JAnnotationUse rootElementAnnotation = classModel.annotate(XmlRootElement.class); rootElementAnnotation.param("name", constantsClass.ref(Util.ROOT_ELEMENT_NAME_FIELD)); // XmlAccessorType JAnnotationUse xmlAccessorTypeAnnotation = classModel.annotate(XmlAccessorType.class); xmlAccessorTypeAnnotation.param("value", XmlAccessType.NONE); // XmlType JAnnotationUse xmlTypeAnnotation = classModel.annotate(XmlType.class); xmlTypeAnnotation.param("name", constantsClass.ref(Util.TYPE_NAME_FIELD)); JAnnotationArrayMember propOrderMember = xmlTypeAnnotation.paramArray("propOrder"); for (FieldModel field : fields) { if (Util.isCommonElement(field.fieldName)) { propOrderMember.param(commonElementsRef.ref(Util.toConstantsVariable(field.fieldName))); } else { propOrderMember.param(elementsClass.ref(Util.toConstantsVariable(field.fieldName))); } } propOrderMember.param(commonElementsRef.ref("FUTURE_ELEMENTS")); }
@Override public JStatement unmarshall(EntityDescriptionGenerator.CreateFromRawEntityHolder holder, PropertyMirror propertyMirror) { JExpression relation = holder.torchFactory .invoke("getRelationResolver") .invoke("with").arg(CodeModelTypes.ref(holder.classHolder.entityMirror.getFullName()).dotclass()) .invoke("onProperty").arg(holder.classHolder.definedClass.staticRef(propertyMirror.getName())) .invoke("parentId").arg(holder.classHolder.entityMirror.getIdPropertyMirror().getGetter().getValue( holder.entity)); return propertyMirror.getSetter().setValue(holder.entity, relation); }
JExpression activitySuper = holder.generatedClass.staticRef("super"); JInvocation superCall = JExpr.invoke(activitySuper, method);
private void addFieldWrite(Attribute attribute, JBlock body) { if ( attribute.attribute.type().isArray() ) { body.staticInvoke(cm.ref("AMQPArray"), "write").arg(_this().ref(attribute.attribute.name())).arg(ref("out")); } else if ( generator.getMapping().get(attribute.type) != null ) { body.staticInvoke(cm.ref(generator.getPrimitiveJavaClass().get(attribute.type)), "write").arg(_this().ref(attribute.attribute.name())).arg(ref("out")); } else { JConditional conditional = body ._if(ref(attribute.attribute.name()).ne(_null())); conditional._then() .invoke(ref(attribute.attribute.name()), "write").arg(ref("out")); conditional._else().invoke(ref("out"), "writeByte").arg(generator.registry().cls().staticRef("NULL_FORMAT_CODE")); } }
lifecycleCallbackRef = builder.getJAXBObjectClass().staticRef(builder.getLifecycleCallbackVar().name());
JFieldVar fieldVar = (JFieldVar) lifecycleCallbackRef; if (builder.getWriteVariableManager().containsId(fieldVar.name())) { lifecycleCallbackRef = builder.getJAXBObjectClass().staticRef(fieldVar.name());