.addMethod(MethodSpec.constructorBuilder() .addModifiers(Modifier.PRIVATE) .addComment("$S", "Not to be instantiated in public") .build()), TypeSpec.classBuilder(NameStore.Class.LAYOUT) .addMethod(MethodSpec.constructorBuilder() .addModifiers(Modifier.PRIVATE) .addComment("$S", "Not to be instantiated in public") .build()), TypeSpec.classBuilder(NameStore.Class.ID) .addMethod(MethodSpec.constructorBuilder() .addModifiers(Modifier.PRIVATE) .addComment("$S", "Not to be instantiated in public") .build()), className,
WildcardTypeName.subtypeOf(columnType) ), "newRows") .addComment("do nothing") .build(); nullSharedTriggersClassBuilder
private MethodSpec constructor() { return MethodSpec.constructorBuilder() .addModifiers(Modifier.PRIVATE) .addComment("No instances") .build(); }
methodBuilder.addComment("force database DDL run"); methodBuilder.beginControlFlow("if (options.populator!=null && instance.justCreated)"); methodBuilder.addComment("run populator only a time"); methodBuilder.addStatement("instance.justCreated=false"); methodBuilder.addComment("run populator"); methodBuilder.addStatement("options.populator.execute()");
methodBuilder.addComment("generate static SQL for statement"); JQLChecker checker = JQLChecker.getInstance();
WildcardTypeName.subtypeOf(columnType) ), "newRows") .addComment("do nothing") .build(); nullSharedTriggersClassBuilder
@Override public void generateWriteProperty(Builder methodBuilder, String editorName, TypeName beanClass, String beanName, PrefsProperty property) { Converter<String, String> formatter = CaseFormat.LOWER_CAMEL.converterTo(CaseFormat.UPPER_CAMEL); String tempPre = ""; String tempPost = ""; if (property.hasTypeAdapter()) { // this comment is needed to include $T for PrefsTypeAdapterUtils methodBuilder.addComment("Use $T to convert objects", PrefsTypeAdapterUtils.class); tempPre = String.format("%s.getAdapter(%s.class).toData(", PrefsTypeAdapterUtils.class.getSimpleName(), TypeUtility.className(property.typeAdapter.adapterClazz).simpleName()); tempPost = ")"; } boolean isStringSet = isStringSet(property); if (!isStringSet) { methodBuilder.beginControlFlow("if ($L!=null) ", getter(beanName, beanClass, property)); methodBuilder.addStatement("String temp=serialize$L($L)", formatter.convert(property.getName()), getter(beanName, beanClass, property)); methodBuilder.addStatement("$L.putString($S,temp)", editorName, property.getPreferenceKey()); methodBuilder.nextControlFlow(" else "); methodBuilder.addStatement("$L.remove($S)", editorName, property.getPreferenceKey()); methodBuilder.endControlFlow(); } else { methodBuilder.addStatement("$L.putStringSet($S," + tempPre + "$L" + tempPost + ")", editorName, property.getPreferenceKey(), getter(beanName, beanClass, property)); } }
@Override public List<MethodSpec> generate(AnnotatedPresenter ap) { final ArrayList<MethodSpec> list = new ArrayList<>(2); String uniqueId = "uniqueId"; String activity = "activity"; String view = "view"; String onDestroy = "onDestroy"; MethodSpec.Builder builder = MethodSpec.methodBuilder(onDestroy) .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .addParameter(String.class, uniqueId) .addParameter(SlickProcessor.ClASS_NAME_ACTIVITY, activity); builder.addStatement("if($L == null || $L.$L.get($L.hashCode()) == null) return", "hostInstance", "hostInstance", "delegates", uniqueId) .addComment("Either has not bound or already has destroyed."); builder.addStatement("$L.$L.get($L.hashCode()).$L($L)", "hostInstance", "delegates", uniqueId, onDestroy, activity) .returns(void.class); list.add(builder.build()); builder = MethodSpec.methodBuilder(onDestroy) .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .addParameter(String.class, uniqueId) .addParameter(SlickProcessor.ClASS_NAME_VIEW, view) .addStatement("$L($L, $L.getActivity($L))", onDestroy, uniqueId, ap.getDelegateType().simpleName(), view) .returns(void.class); list.add(builder.build()); return list; }
/** * Generate subject next. * * @param entity * * @param methodBuilder * the method builder * @param subjectType * the subject type * @param value */ public static void generateSubjectNext(SQLiteEntity entity, MethodSpec.Builder methodBuilder, SubjectType subjectType, String value) { String subInsertType = ""; if (subjectType == SubjectType.INSERT) { if (entity.getPrimaryKey().isType(String.class)) { subInsertType = "WithUid"; } else { subInsertType = "WithId"; } } methodBuilder.beginControlFlow("if (result>0)"); methodBuilder.addComment("rx management "); methodBuilder.addStatement("subject.onNext($T.create$L$L($L))", SQLiteEvent.class, subjectType.value(), subInsertType, value); methodBuilder.endControlFlow(); }
private TypeSpec createRouteProvider(List<Element> elements, String providerName) { ClassName list = ClassName.get("java.util", "List"); ClassName arrayList = ClassName.get("java.util", "ArrayList"); TypeName listOfRoutes = ParameterizedTypeName.get(list, JOURNEY_CONTROLLER_ROUTE); TypeSpec.Builder provider = TypeSpec.classBuilder(capitalize(providerName) + "JourneyProvider"); provider.addModifiers(Modifier.PUBLIC, Modifier.FINAL); provider.addSuperinterface(JOURNEY_ROUTES_PROVIDER); MethodSpec.Builder provideRoutesMethod = MethodSpec.methodBuilder("provideRoutes") .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .returns(listOfRoutes) .addStatement("$T result = new $T<>()", listOfRoutes, arrayList); for (Element e : elements) { TypeSpec creator = generateCreator(e); String path = e.getAnnotation(Route.class).value(); Pair<String, Set<String>> pair = pathToPatternAndParams(path); CodeBlock params = generateRouteParams(pair.second); provideRoutesMethod.addComment("Route defined as $S", path); provideRoutesMethod.addStatement("result.add(new $T($S, $L, $L))", JOURNEY_CONTROLLER_ROUTE, pair.first, params, creator); } provideRoutesMethod.addStatement("return result"); return provider.addMethod(provideRoutesMethod.build()).build(); }
/** * generate code for sub queries * * @param methodBuilder * @param method */ protected void generateSubQueries(Builder methodBuilder, SQLiteModelMethod method) { SQLiteEntity entity = method.getEntity(); for (Triple<String, String, SQLiteModelMethod> item : method.childrenSelects) { TypeName entityTypeName = TypeUtility.typeName(entity.getElement()); String setter; if (entity.isImmutablePojo()) { String idGetter = ImmutableUtility.IMMUTABLE_PREFIX + entity.getPrimaryKey().getName(); setter = ImmutableUtility.IMMUTABLE_PREFIX + entity.findRelationByParentProperty(item.value0).value0.getName() + "=" + String.format("this.daoFactory.get%s().%s(%s)", item.value2.getParent().getName(), item.value2.getName(), idGetter); } else { String idGetter = PropertyUtility.getter("resultBean", entityTypeName, entity.getPrimaryKey()); setter = PropertyUtility.setter(entityTypeName, "resultBean", entity.findRelationByParentProperty(item.value0).value0, String.format("this.daoFactory.get%s().%s(%s)", item.value2.getParent().getName(), item.value2.getName(), idGetter)); } methodBuilder.addComment("sub query: $L", setter); methodBuilder.addStatement("$L", setter); } }
public void generateTotalSpecializedPart(SQLiteModelMethod method, MethodSpec.Builder methodBuilder) { SQLiteDaoDefinition daoDefinition = method.getParent(); methodBuilder.addComment("manage query for total count eements"); methodBuilder.addStatement("int _result=-1"); methodBuilder.addCode("\n"); methodBuilder.beginControlFlow("if (_cursor.moveToFirst())"); methodBuilder.addStatement("_result=_cursor.getInt(0)"); methodBuilder.endControlFlow(); if (daoDefinition.isLogEnabled()) { // generate log section - BEGIN methodBuilder.addComment("log section for select BEGIN"); methodBuilder.beginControlFlow("if (_context.isLogEnabled())"); // manage log methodBuilder.addComment("manage log"); // log for where parames SqlBuilderHelper.generateLogForWhereParameters(method, methodBuilder); methodBuilder.addStatement("$T.info($S, _result)", Logger.class, "Total elements found: %s"); // generate log section - END methodBuilder.addComment("log section for select END"); } methodBuilder.endControlFlow(); methodBuilder.addStatement("return _result"); methodBuilder.endControlFlow(); }
private static MethodSpec createInitDefaultsMethod(Collection<PreferenceInformation> allPreferences) { MethodSpec.Builder initDefaultsBuilder = MethodSpec.methodBuilder("initDefaults") .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .returns(void.class) .addStatement("SharedPreferences.Editor editor = preferences.edit()"); for (PreferenceInformation info : allPreferences) { if (info.getter != null) { String methodSuffix = Utils.getMethodSuffix(info.preferenceType.getPreferenceType()); String value = "this." + info.preferenceName + "()"; if (info.preferenceType.getPreferenceType() == PreferenceType.OBJECT) { value = "Esperandro.getSerializer().serialize(" + value + ")"; } initDefaultsBuilder.addStatement("editor.put$L($S, $L)", methodSuffix, info.preferenceName, value); } else { initDefaultsBuilder.addComment("no default initialization possible for '$L'", info.preferenceName); } } initDefaultsBuilder.addStatement("editor.commit()"); return initDefaultsBuilder.build(); }
/** * * @param entity * @param methodBuilder * @param entityName */ public static void generateImmutableVariableCopyFromEntity(ModelClass<?> entity, Builder methodBuilder, String entityName) { methodBuilder.addComment( "immutable object: initialize temporary variables for properties with entity propertiy values"); for (Pair<String, TypeName> property : entity.getImmutableConstructors()) { ModelProperty item = entity.findImmutablePropertyByName(property.value0); AssertKripton.assertTrue(item != null, "Can not found property '%s' (type %s) in class '%s'", property.value0, property.value1, entity.getName()); methodBuilder.addCode("$L$L=$L.$L;\n", IMMUTABLE_PREFIX, property.value0, entityName, PropertyUtility.getter(item)); } }
/** * Generate instance of shared preferences. * * @param className * the class name */ private static void generateInstance(String className) { builder.addField(FieldSpec.builder(className(className), "instance", Modifier.PRIVATE, Modifier.STATIC).addJavadoc("instance of shared preferences\n").build()); // instance MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("getInstance").addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.SYNCHRONIZED) .addJavadoc("get instance of shared preferences\n").returns(className(className)); methodBuilder.beginControlFlow("if (instance==null)"); methodBuilder.addStatement("instance=new $L()", className(className)); methodBuilder.addComment("read and write instance to sync with default values"); methodBuilder.addStatement("instance.write(instance.read())"); methodBuilder.endControlFlow(); methodBuilder.addCode("return instance;\n"); builder.addMethod(methodBuilder.build()); }
@Override public void generate(TypeSpec.Builder classBuilder, boolean mapFields, SQLiteModelMethod method) { Set<JQLProjection> fieldList = JQLChecker.getInstance().extractProjections(method, method.jql.value, method.getEntity()); // generate method code MethodSpec.Builder methodBuilder = generateMethodBuilder(method); generateCommonPart(method, classBuilder, methodBuilder, fieldList, true); methodBuilder.addComment("Specialized part - $L - BEGIN", this.getClass().getSimpleName()); generateSpecializedPart(method, classBuilder, methodBuilder, fieldList, selectType.isMapFields()); methodBuilder.addComment("Specialized part - $L - END", this.getClass().getSimpleName()); if (!method.isPagedLiveData()) { // method ForLiveData do not have to be generated for paged live // data classBuilder.addMethod(methodBuilder.build()); } }
@Override public void generate(AnnotatedPresenter ap, MethodSpec.Builder builder) { builder.addStatement("if($L == null || $L.$L.get($T.getId($L)) == null) return", "hostInstance", "hostInstance", "delegates", ap.getDelegateType(), ap.getViewVarName()) .addComment("Already has called by its delegate."); } }
private static void generateImmutableVariableInternal(ModelClass<?> entity, Builder methodBuilder, boolean declare) { methodBuilder.addComment("immutable object: initialize temporary variables for properties"); for (Pair<String, TypeName> property : entity.getImmutableConstructors()) { if (declare) { methodBuilder.addCode("$T ", property.value1); } methodBuilder.addCode("$L$L=$L;\n", IMMUTABLE_PREFIX, property.value0, TypeUtility.getDefaultValue(property.value1)); } }
@Override public String onBindParameter(String bindParameterName, boolean inStatement) { if (!inStatement) { return "?"; } else { methodBuilder.addComment("need to use $T operations", SpreadUtils.class); dynamicCodeBlock.append((dynamicCodeBlock.length() > 0 ? "," : "") + String.format("SpreadUtils.generateQuestion(%s)", method.findParameterNameByAlias(bindParameterName))); return "%s"; } } });
private void generateTotalCountUsage(SQLiteModelMethod method, Builder methodBuilder, String paginatedResultName, String selectTotalCountMethodName) { methodBuilder.addComment("total count - BEGIN"); methodBuilder.addCode(paginatedResultName+".setTotalElements(this."+selectTotalCountMethodName+"("); method.getParameters().forEach(p -> { methodBuilder.addCode(p.value0+", "); }); methodBuilder.addCode(paginatedResultName+"));\n"); methodBuilder.addComment("total count - END"); }