From 14d36588fc66519d4f18b9ce7b2b1f949eebfd8c Mon Sep 17 00:00:00 2001 From: Kaspar Etter Date: Wed, 23 May 2018 14:33:44 +0200 Subject: [PATCH 1/3] Made configurations log their initialization. --- .../utility/configuration/Configuration.java | 21 +++++++++++++++++++ .../initializer/UtilityInitializer.java | 9 ++++++++ 2 files changed, 30 insertions(+) diff --git a/configuration/src/main/java/net/digitalid/utility/configuration/Configuration.java b/configuration/src/main/java/net/digitalid/utility/configuration/Configuration.java index 8ace54e2..34354adc 100644 --- a/configuration/src/main/java/net/digitalid/utility/configuration/Configuration.java +++ b/configuration/src/main/java/net/digitalid/utility/configuration/Configuration.java @@ -37,6 +37,7 @@ import net.digitalid.utility.configuration.errors.InitializerError; import net.digitalid.utility.configuration.errors.InitializerErrorBuilder; import net.digitalid.utility.contracts.Require; +import net.digitalid.utility.functional.interfaces.Consumer; import net.digitalid.utility.functional.iterables.FiniteIterable; import net.digitalid.utility.validation.annotations.method.Chainable; import net.digitalid.utility.validation.annotations.type.Functional; @@ -190,6 +191,14 @@ public int getLineNumber() { return getClassName(); } + /** + * Returns the qualified name of the class and the line number where this configuration is declared. + */ + @Pure + public @Nonnull String toLongString() { + return new StringBuilder(getQualifiedClassName()).append(":").append(getLineNumber()).toString(); + } + /* -------------------------------------------------- Configurations -------------------------------------------------- */ /** @@ -364,6 +373,13 @@ public boolean dependsOn(@Nonnull Configuration configuration) { return this; } + /* -------------------------------------------------- Configuration -------------------------------------------------- */ + + /** + * Stores a consumer that logs the initialization if set. + */ + public static final @Nonnull Configuration> logger = Configuration.withUnknownProvider(); + /* -------------------------------------------------- Initialization -------------------------------------------------- */ private boolean initialized = false; @@ -386,6 +402,11 @@ public void initialize() { if (!initialized) { this.initialized = true; for (@Nonnull Configuration dependency : dependencies) { dependency.initialize(); } + if (logger.isSet()) { + final @Nonnull StringBuilder string = new StringBuilder("Initializing ").append(toLongString().replace("net.digitalid.", "")); + if (!dependencies.isEmpty()) { string.append(" depending on ").append(FiniteIterable.of(dependencies).join()); } + logger.get().consume(string.toString()); + } for (@Nonnull Initializer initializer : initializers) { try { initializer.execute(); diff --git a/initializer/src/main/java/net/digitalid/utility/initializer/UtilityInitializer.java b/initializer/src/main/java/net/digitalid/utility/initializer/UtilityInitializer.java index d0517069..2dee8126 100644 --- a/initializer/src/main/java/net/digitalid/utility/initializer/UtilityInitializer.java +++ b/initializer/src/main/java/net/digitalid/utility/initializer/UtilityInitializer.java @@ -122,6 +122,15 @@ public static void initializeLogger() throws FileNotFoundException { } } + /** + * Initializes the logger of the configuration class. + */ + @PureWithSideEffects + @Initialize(target = Configuration.class, dependencies = Logger.class) + public static void initializeConfigurationLogger() { + Configuration.logger.set(string -> Log.debugging(string)); + } + /* -------------------------------------------------- Threading -------------------------------------------------- */ /** From 704346c662b3c822b6ec135ecae4848e68381eee Mon Sep 17 00:00:00 2001 From: Kaspar Etter Date: Fri, 25 May 2018 16:31:45 +0200 Subject: [PATCH 2/3] Changed in the converter generator that non-representative fields can also be provided. --- .../generators/ConverterGenerator.java | 42 +++++++++---------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/generator/src/main/java/net/digitalid/utility/generator/generators/ConverterGenerator.java b/generator/src/main/java/net/digitalid/utility/generator/generators/ConverterGenerator.java index c3b6dfb2..a6ba21bd 100644 --- a/generator/src/main/java/net/digitalid/utility/generator/generators/ConverterGenerator.java +++ b/generator/src/main/java/net/digitalid/utility/generator/generators/ConverterGenerator.java @@ -118,19 +118,19 @@ private String importConverterType(@Nonnull TypeMirror typeMirror, @Nonnull Fini /* -------------------------------------------------- Externally and Non-Externally Provided Fields -------------------------------------------------- */ /** - * Returns all field information objects that do not have a @Provided annotation. + * Returns the fields that have to be converted (because they are representative but not provided). */ @Pure - private @Nonnull FiniteIterable<@Nonnull FieldInformation> filterNonExternallyProvidedFields(@Nonnull FiniteIterable<@Nonnull FieldInformation> fieldInformation) { - return fieldInformation.filter(field -> !field.hasAnnotation(Provided.class)); + private @Nonnull FiniteIterable<@Nonnull FieldInformation> getFieldsToBeConverted() { + return typeInformation.getRepresentingFieldInformation().filter(field -> !field.hasAnnotation(Provided.class)); } /** - * Returns all field information objects that do have a @Provided annotation. + * Returns the fields that are provided (and thus do not need to be converted). */ @Pure - private @Nonnull FiniteIterable<@Nonnull FieldInformation> filterExternallyProvidedFields(@Nonnull FiniteIterable<@Nonnull FieldInformation> fieldInformation) { - return fieldInformation.filter(field -> field.hasAnnotation(Provided.class)); + private @Nonnull FiniteIterable<@Nonnull FieldInformation> getProvidedFields() { + return typeInformation.getFieldInformation().filter(field -> field.hasAnnotation(Provided.class)); } /** @@ -140,15 +140,15 @@ private String importConverterType(@Nonnull TypeMirror typeMirror, @Nonnull Fini @SuppressWarnings("AssignmentToMethodParameter") private @Nonnull String getExternallyProvidedParameterDeclarationsAsString(@Nonnull String postFix) { postFix = postFix.isEmpty() ? postFix : " " + postFix; - final @Nonnull FiniteIterable<@Nonnull FieldInformation> externallyProvidedFields = filterExternallyProvidedFields(typeInformation.getRepresentingFieldInformation()); - final @Nonnull String parameterTypes = externallyProvidedFields.map(field -> importIfPossible(field.getType())).join(); - final @Nullable Class tupleType = Tuple.getTupleType(externallyProvidedFields.size()); + final @Nonnull FiniteIterable<@Nonnull FieldInformation> providedFields = getProvidedFields(); + final @Nonnull String parameterTypes = providedFields.map(field -> importIfPossible(field.getType())).join(); + final @Nullable Class tupleType = Tuple.getTupleType(providedFields.size()); if (tupleType == null) { - switch (externallyProvidedFields.size()) { + switch (providedFields.size()) { case 0: return importIfPossible(Void.class) + postFix; case 1: - return importIfPossible(externallyProvidedFields.getFirst().getType()) + postFix; + return importIfPossible(providedFields.getFirst().getType()) + postFix; default: throw FailedClassGenerationException.with("Cannot accept more than 8 externally provided parameters."); } @@ -161,12 +161,12 @@ private String importConverterType(@Nonnull TypeMirror typeMirror, @Nonnull Fini */ @Pure private @Nonnull String getExternallyProvidedParameterNameAsString() { - final @Nonnull FiniteIterable<@Nonnull FieldInformation> externallyProvidedFields = filterExternallyProvidedFields(typeInformation.getRepresentingFieldInformation()); - switch (externallyProvidedFields.size()) { + final @Nonnull FiniteIterable<@Nonnull FieldInformation> providedFields = getProvidedFields(); + switch (providedFields.size()) { case 0: return "none"; case 1: - return externallyProvidedFields.getFirst().getName(); + return providedFields.getFirst().getName(); case 2: case 3: case 4: @@ -277,7 +277,7 @@ private void generateConvertMethod() { addAnnotation(Pure.class); addAnnotation(Override.class); beginMethod("public " + Brackets.inPointy("EXCEPTION extends " + importIfPossible(ConnectionException.class)) + " void convert(@" + importIfPossible(NonCaptured.class) + " @" + importIfPossible(Unmodified.class) + " @" + importIfPossible(Nonnull.class) + " " + typeInformation.getName() + " " + getObjectVariableName() + ", @" + importIfPossible(Nonnull.class) + " @" + importIfPossible(NonCaptured.class) + " @" + importIfPossible(Modified.class) + " " + importIfPossible(Encoder.class) + Brackets.inPointy("EXCEPTION") + " encoder) throws EXCEPTION"); - filterNonExternallyProvidedFields(typeInformation.getRepresentingFieldInformation()).doForEach(this::addEncodingStatement); + getFieldsToBeConverted().doForEach(this::addEncodingStatement); // for (@Nonnull FieldInformation field : fields) { // final @Nonnull String fieldAccess = objectVariableName + "." + field.getAccessCode(); // addStatement("i *= " + generateValueCollectorCall(fieldAccess, field.getType(), 1)); @@ -411,16 +411,16 @@ protected void generateRecoverMethod() { addAnnotation(Pure.class); addAnnotation(Override.class); beginMethod("public @" + importIfPossible(Capturable.class) + " @" + importIfPossible(Nonnull.class) + " " + Brackets.inPointy("EXCEPTION extends " + importIfPossible(ConnectionException.class)) + " " + typeInformation.getName() + " recover(@" + importIfPossible(Nonnull.class) + " @" + importIfPossible(NonCaptured.class) + " " + importIfPossible(Decoder.class) + Brackets.inPointy("EXCEPTION") + " decoder, " + getExternallyProvidedParameterDeclarationsAsString(getExternallyProvidedParameterNameAsString()) + ") throws EXCEPTION, " + importIfPossible(RecoveryException.class)); - final @Nonnull FiniteIterable<@Nonnull FieldInformation> externallyProvidedFields = filterExternallyProvidedFields(typeInformation.getRepresentingFieldInformation()); + final @Nonnull FiniteIterable<@Nonnull FieldInformation> providedFields = getProvidedFields(); - if (externallyProvidedFields.size() > 1) { + if (providedFields.size() > 1) { int i = 0; - for (@Nonnull FieldInformation externallyProvidedField : externallyProvidedFields) { + for (@Nonnull FieldInformation externallyProvidedField : providedFields) { addStatement("final " + importIfPossible(externallyProvidedField.getType()) + " " + externallyProvidedField.getName() + " = provided.get" + i++ + "()"); } } - final @Nonnull FiniteIterable<@Nonnull FieldInformation> fields = filterNonExternallyProvidedFields(typeInformation.getRepresentingFieldInformation()); + final @Nonnull FiniteIterable<@Nonnull FieldInformation> fields = getFieldsToBeConverted(); // for (@Nonnull FieldInformation constructorParameter : fields) { // final @Nonnull String provide = constructorParameter.hasAnnotation(Provide.class) ? constructorParameter.getAnnotation(Provide.class).value() : "null"; @@ -434,7 +434,7 @@ protected void generateRecoverMethod() { fields.doForEach(this::addDecodingStatement); final @Nullable ExecutableInformation recoverConstructorOrMethod = typeInformation.getRecoverConstructorOrMethod(); if (!getThrownTypesOfInitializeMethod().isEmpty() || recoverConstructorOrMethod != null && recoverConstructorOrMethod.throwsExceptions()) { beginTry(); } - addStatement(typeInformation.getInstantiationCode(true, true, true, externallyProvidedFields.combine(fields))); + addStatement(typeInformation.getInstantiationCode(true, true, true, providedFields.combine(fields))); if (!getThrownTypesOfInitializeMethod().isEmpty() || recoverConstructorOrMethod != null && recoverConstructorOrMethod.throwsExceptions()) { if (recoverConstructorOrMethod != null && recoverConstructorOrMethod.throwsExceptions()) { endTryOrCatchBeginCatch(recoverConstructorOrMethod.getElement().getThrownTypes()); @@ -477,7 +477,7 @@ private void generateFields() { final @Nonnull StringBuilder fieldsString = new StringBuilder(); final @Nonnull List<@Nonnull String> statements = new ArrayList<>(); boolean addedMap = false; - for (@Nonnull FieldInformation representingField : filterNonExternallyProvidedFields(typeInformation.getRepresentingFieldInformation())) { + for (@Nonnull FieldInformation representingField : getFieldsToBeConverted()) { final @Nonnull StringBuilder customAnnotations = new StringBuilder(); final @Nonnull FiniteIterable<@Nonnull AnnotationMirror> annotations = representingField.getAnnotations(); final @Nonnull String fieldName = representingField.getName(); From 785722e47eed5e75e13ae445c7e0d9b738f81274 Mon Sep 17 00:00:00 2001 From: Kaspar Etter Date: Wed, 25 Jul 2018 18:58:50 +0200 Subject: [PATCH 3/3] Made the execute method of the initializer public. --- .../java/net/digitalid/utility/configuration/Initializer.java | 2 +- .../digitalid/utility/initialization/LoggingInitializer.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/configuration/src/main/java/net/digitalid/utility/configuration/Initializer.java b/configuration/src/main/java/net/digitalid/utility/configuration/Initializer.java index 967f95e1..750b8f04 100644 --- a/configuration/src/main/java/net/digitalid/utility/configuration/Initializer.java +++ b/configuration/src/main/java/net/digitalid/utility/configuration/Initializer.java @@ -58,6 +58,6 @@ protected Initializer(@NonCaptured @Modified @Nonnull Configuration target, @ * @throws Exception if any problems occur. */ @Impure - protected abstract void execute() throws Exception; + public abstract void execute() throws Exception; } diff --git a/initialization/src/main/java/net/digitalid/utility/initialization/LoggingInitializer.java b/initialization/src/main/java/net/digitalid/utility/initialization/LoggingInitializer.java index 530940ff..0b001920 100644 --- a/initialization/src/main/java/net/digitalid/utility/initialization/LoggingInitializer.java +++ b/initialization/src/main/java/net/digitalid/utility/initialization/LoggingInitializer.java @@ -59,7 +59,7 @@ protected LoggingInitializer(@NonCaptured @Modified @Nonnull Configuration ta @Impure @Override - protected final void execute() throws Exception { + public final void execute() throws Exception { Log.debugging("The initializer " + this + " begins its execution."); final long start = System.currentTimeMillis(); executeWithoutLogging();