addressing more review comments

Author: trentjeff

pico/api/src/main/java/io/helidon/pico/api/Contract.java

@@ -29,7 +29,6 @@
  *
  * If the developer does not have access to the source to place this annotation on the interface definition then consider using
  * {@link ExternalContracts} instead - this annotation can be placed on the implementation class implementing the given interface.
- *
  * See io.helidon.pico.spi.ServiceInfo#getContractsImplemented()
  */
 @Documented

pico/api/src/main/java/io/helidon/pico/api/ExternalContracts.java

@@ -23,7 +23,7 @@
 
 /**
  * Placed on the implementation of a service as an alternative to using a {@link Contract}.
- *
+ * <p>
  * Use this annotation when it is impossible to place an annotation on the interface itself - for instance of the interface comes
  * from a 3rd party library/provider.
  */

pico/types/pom.xml

@@ -31,13 +31,4 @@
     <name>Helidon Pico Types</name>
     <description>Provides the runtime types (a subset of SPI) useful for Pico</description>
 
-    <dependencies>
-        <dependency>
-            <!-- for @JsonIgnore use only -->
-            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>jackson-annotations</artifactId>
-            <scope>provided</scope>
-        </dependency>
-    </dependencies>
-
 </project>

pico/types/src/main/java/io/helidon/pico/types/AnnotationAndValue.java

@@ -25,41 +25,41 @@
 public interface AnnotationAndValue {
 
     /**
-     * The type name, e.g., {@link jakarta.inject.Named} -> "jakarta.inject.Named".
+     * The type name, e.g., {@link java.util.Objects} -> "java.util.Objects".
      *
      * @return the annotation type name
      */
-    TypeName getTypeName();
+    TypeName typeName();
 
     /**
      * The value property.
      *
      * @return The string value of value property, or null if no value is present
      */
-    String getValue();
+    String value();
 
     /**
      * Get a value of an annotation property.
      *
      * @param name name of the annotation property
      * @return string value of the property
      */
-    String getValue(String name);
+    String valueOf(String name);
 
     /**
      * Get a key-value of all the annotation properties.
      *
      * @return key-value pairs of all the properties present
      */
-    Map<String, String> getValues();
+    Map<String, String> values();
 
     /**
-     * Determines whether the {@link #getValue()} is a non-null and non-blank value.
+     * Determines whether the {@link #value()} is a non-null and non-blank value.
      *
      * @return true if the value provided is non-null and non-blank (i.e., {@link String#isBlank()})
      */
-    default boolean hasValue() {
-        return hasValue(getValue());
+    default boolean hasNonBlankValue() {
+        return hasNonBlankValue(value());
     }
 
     /**
@@ -68,7 +68,7 @@ default boolean hasValue() {
      * @param val the value to check
      * @return true if the value provided is non-null and non-blank.
      */
-    static boolean hasValue(String val) {
+    static boolean hasNonBlankValue(String val) {
         return Objects.nonNull(val) && !val.isBlank();
     }
 

pico/types/src/main/java/io/helidon/pico/types/TypeName.java

@@ -18,27 +18,25 @@
 
 import java.util.List;
 
-import com.fasterxml.jackson.annotation.JsonIgnore;
-
 /**
  * TypeName is similar to {@link java.lang.reflect.Type} in its most basic use case. The {@link #getName()} returns the package +
  * class name tuple for the given type (i.e., the canonical type name).
  * <p>
  *
  * This class also provides a number of methods that are typically found in {@link java.lang.Class} that can be used to avoid
  * classloading resolution:
- * <li>{@link #getPackageName()} and {@link #getClassName()} - access to the package and simple class names.
- * <li>{@link #isPrimitive()} and {@link #isArray()} - access to flags that is typically found in {@link java.lang.Class}.
+ * <li>{@link #packageName()} and {@link #className()} - access to the package and simple class names.
+ * <li>{@link #primitive()} and {@link #array()} - access to flags that is typically found in {@link java.lang.Class}.
  * <p>
  *
  * Additionally, this class offers a number of additional methods that are useful for handling generics:
- * <li>{@link #isGeneric()} - true when this type is declared to include generics (i.e., has type arguments).
- * <li>{@link #isWildcard()} - true if using wildcard generics usage.
- * <li>{@link #getTypeArguments()} - access to generics / parametrized type information.
+ * <li>{@link #generic()} - true when this type is declared to include generics (i.e., has type arguments).
+ * <li>{@link #wildcard()} - true if using wildcard generics usage.
+ * <li>{@link #typeArguments()} - access to generics / parametrized type information.
  * <p>
  *
  * Finally, this class offers a number of methods that are helpful for code generation:
- * <li>{@link #getDeclaredName()} and {@link #getFQName()}.
+ * <li>{@link #declaredName()} and {@link #fqName()}.
  */
 public interface TypeName extends Comparable<TypeName> {
 
@@ -47,64 +45,55 @@ public interface TypeName extends Comparable<TypeName> {
      *
      * @return the package name
      */
-    @JsonIgnore
-    String getPackageName();
+    String packageName();
 
     /**
      * Functions the same as {@link Class#getSimpleName()}.
      *
      * @return the simple class name
      */
-    @JsonIgnore
-    String getClassName();
+    String className();
 
     /**
      * Functions the same as {@link Class#isPrimitive()}.
      *
      * @return true if this type represents a primitive type.
      */
-    @JsonIgnore
-    boolean isPrimitive();
+    boolean primitive();
 
     /**
      * Functions the same as {@link Class#isArray()}.
      *
      * @return true if this type represents a primitive array [].
      */
-    @JsonIgnore
-    boolean isArray();
+    boolean array();
 
     /**
      * @return used to represent a generic (e.g., "Optional<CB>").
      */
-    @JsonIgnore
-    boolean isGeneric();
+    boolean generic();
 
     /**
      * @return used to represent a wildcard (e.g., "? extends SomeType").
      */
-    @JsonIgnore
-    boolean isWildcard();
+    boolean wildcard();
 
     /**
      * @return the type arguments of this type, if this type supports generics/parameterized type.
      */
-    @JsonIgnore
-    List<TypeName> getTypeArguments();
+    List<TypeName> typeArguments();
 
     /**
      * Typically used as part of code-gen, when ".class" is tacked onto the suffix of what this returns.
      *
      * @return same as getName() unless the type is an array, and then will add "[]" to the return.
      */
-    @JsonIgnore
-    String getDeclaredName();
+    String declaredName();
 
     /**
      * @return the fully qualified name which includes the use of generics/parameterized types, arrays, etc.
      */
-    @JsonIgnore
-    String getFQName();
+    String fqName();
 
     /**
      * @return the base type name given the set package and class name, but not including the generics/parameterized types.

pico/types/src/main/java/module-info.java

@@ -18,7 +18,5 @@
  * Pico minimal (spi) types module.
  */
 module io.helidon.pico.types {
-    requires static com.fasterxml.jackson.annotation;
-
     exports io.helidon.pico.types;
 }