开源软件构建与测试

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Changes of Revision 3

_service:tar_scm:joda-convert.spec Changed

@@ -1,13 +1,20 @@
 Name: joda-convert
-Version: 1.9.2
+Version: 2.2.3
 Release: 1
 Summary: Java library for conversion to and from standard string formats
 License: ASL 2.0
 URL: https://github.com/JodaOrg/joda-convert/
 BuildArch: noarch
-Source0: https://github.com/JodaOrg/joda-convert/archive/v%{version}.tar.gz#/%{name}-%{version}.tar.gz
+Source0: https://github.com/JodaOrg/joda-convert/archive/refs/tags/%{name}-2.2.3.tar.gz
 BuildRequires: maven-local mvn(org.apache.felix:maven-bundle-plugin)
 BuildRequires: mvn(org.apache.maven.plugins:maven-assembly-plugin)
+BuildRequires: mvn(org.jacoco:jacoco-maven-plugin)
+BuildRequires: mvn(org.apache.maven.plugins:maven-site-plugin)
+BuildRequires: mvn(org.apache.maven.plugins:maven-dependency-plugin)
+BuildRequires: mvn(com.google.guava:guava)
+BuildRequires: java-11-openjdk-devel
+Requires: java-11-openjdk	
+Requires: javapackages-tools
 %description
 Java library to enable conversion to and from standard string formats.
 
@@ -23,9 +30,12 @@
 %pom_remove_plugin :maven-checkstyle-plugin
 %pom_remove_plugin :maven-source-plugin
 %pom_remove_plugin :maven-javadoc-plugin
+%pom_remove_plugin org.apache.maven.plugins:maven-surefire-plugin
+%pom_remove_plugin org.apache.maven.plugins:maven-site-plugin
 
 %build
-%mvn_build
+export JAVA_HOME=%{_jvmdir}/java-11-openjdk
+%mvn_build -f
 
 %install
 %mvn_install
@@ -37,5 +47,8 @@
 %doc LICENSE.txt NOTICE.txt
 
 %changelog
+* Mon Sep 18 2023 Ge Wang <wang__ge@126.com> -2.2.3-1
+- Update to version 2.2.3
+
 * Wed Jul 29 2020 zhanghua <zhanghua40@huawei.com> - 1.9.2-1
 - package init

_service Changed

_service:tar_scm:joda-convert-1.9.2.tar.gz/.travis.yml Deleted

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/AbstractTypeStringConverter.java Deleted

@@ -1,174 +0,0 @@
-/*
- * Copyright 2010-present Stephen Colebourne
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.joda.convert;
-
-import java.lang.reflect.Array;
-import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.List;
-
-import com.google.common.collect.ImmutableMap;
-
-/**
- * Parse the string format of Guava TypeToken.
- * 
- * This is loaded by reflection only when Guava is on the classpath.
- * It relies on internal methods in Guava that could change in any release.
- * 
- * This parser is incomplete, but handles common cases.
- * It does not handle union types or multi-dimensional arrays.
- */
-abstract class AbstractTypeStringConverter {
-
- // extends
- private static final String EXTENDS = "? extends ";
-
- // super
- private static final String SUPER = "? super ";
-
- // primitive types
- private static final ImmutableMap<String, Class<?>> PRIMITIVES = ImmutableMap.<String, Class<?>>builder()
- .put("byte", byte.class)
- .put("short", short.class)
- .put("int", int.class)
- .put("long", long.class)
- .put("boolean", boolean.class)
- .put("char", char.class)
- .put("float", float.class)
- .put("double", double.class)
- .build();
-
- private static final Method NEW_PARAM_TYPE;
- private static final Method EXTENDS_TYPE;
- private static final Method SUPER_TYPE;
- static {
- try {
- Class<?> typesClass = RenameHandler.INSTANCE.loadType("com.google.common.reflect.Types");
- Method newParam = typesClass.getDeclaredMethod("newParameterizedType", Class.class, Type.class);
- newParam.setAccessible(true);
- NEW_PARAM_TYPE = newParam;
- Method extendsType = typesClass.getDeclaredMethod("subtypeOf", Type.class);
- extendsType.setAccessible(true);
- EXTENDS_TYPE = extendsType;
- Method superType = typesClass.getDeclaredMethod("supertypeOf", Type.class);
- superType.setAccessible(true);
- SUPER_TYPE = superType;
- } catch (Exception ex) {
- throw new RuntimeException(ex);
- }
- }
-
- //-----------------------------------------------------------------------
- // constructor
- AbstractTypeStringConverter() {
- }
-
- //-----------------------------------------------------------------------
- /**
- * Parses the TypeToken string format.
- * 
- * @param str the string
- * @return the token
- */
- static Type parse(String str) {
- try {
- return doParse(str);
- } catch (RuntimeException ex) {
- throw ex;
- } catch (Exception ex) {
- throw new RuntimeException(ex);
- }
- }
-
- // parse an element
- private static Type doParse(String str) throws Exception {
- Class<?> token = PRIMITIVES.get(str);
- if (token != null) {
- return token;
- }
- int first = str.indexOf('<');
- if (first < 0) {
- return RenameHandler.INSTANCE.loadType(str);
- }
- int last = str.lastIndexOf('>');
- String baseStr = str.substring(0, first);
- Class<?> base = RenameHandler.INSTANCE.loadType(baseStr);
- String argsStr = str.substring(first + 1, last);
- List<String> splitArgs = split(argsStr);
- List<Type> types = new ArrayList<Type>();
- for (String splitArg : splitArgs) {
- Type argType;
- if (splitArg.startsWith(EXTENDS)) {
- String remainder = splitArg.substring(EXTENDS.length());
- argType = wildExtendsType(doParse(remainder));
- } else if (splitArg.startsWith(SUPER)) {
- String remainder = splitArg.substring(SUPER.length());
- argType = wildSuperType(doParse(remainder));
- } else if (splitArg.equals("?")) {
- argType = wildExtendsType(Object.class);
- } else if (splitArg.endsWith("")) {
- String componentStr = splitArg.substring(0, splitArg.length() - 2);
- Class<?> componentCls = RenameHandler.INSTANCE.loadType(componentStr);
- argType = Array.newInstance(componentCls, 0).getClass();
- } else if (splitArg.startsWith("L") && splitArg.endsWith(";")) {
- String componentStr = splitArg.substring(2, splitArg.length() - 1);
- Class<?> componentCls = RenameHandler.INSTANCE.loadType(componentStr);
- argType = Array.newInstance(componentCls, 0).getClass();
- } else {
- argType = doParse(splitArg);
- }
- types.add(argType);
- }
- return newParameterizedType(base, types.toArray(new Typetypes.size()));
- }
-
- // split by comma, handling nested generified types
- private static List<String> split(String str) {
- List<String> result = new ArrayList<String>();
- int genericCount = 0;
- int startPos = 0;
- for (int i = 0; i < str.length(); i++) {
- if (str.charAt(i) == ',' && genericCount == 0) {
- result.add(str.substring(startPos, i).trim());
- startPos = i + 1;
- } else if (str.charAt(i) == '<') {
- genericCount++;
- } else if (str.charAt(i) == '>') {
- genericCount--;
- }
- }
- result.add(str.substring(startPos).trim());
- return result;
- }
-
- // create a type representing "? extends X"
- private static Type wildExtendsType(Type bound) throws Exception {
- return (Type) EXTENDS_TYPE.invoke(null, bound);
- }
-
- // create a type representing "? super X"
- private static Type wildSuperType(Type bound) throws Exception {
- return (Type) SUPER_TYPE.invoke(null, bound);
- }
-
- // create a type representing "base<args...>"
- private static ParameterizedType newParameterizedType(final Class<?> base, Type... args) throws Exception {
- return (ParameterizedType) NEW_PARAM_TYPE.invoke(null, base, args);
- }
-
-}

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/MethodConstructorStringConverter.java Deleted

@@ -1,87 +0,0 @@
-/*
- * Copyright 2010-present Stephen Colebourne
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.joda.convert;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-
-/**
- * Conversion to and from a string using a toString method and a fromString constructor.
- * 
- * The toString method must meet the following signature: 
- * {@code String anyName()} on Class T.
- * 
- * The fromString constructor must take a single {@code String} parameter.
- * 
- * MethodConstructorStringConverter is thread-safe and immutable.
- * 
- * @param <T> the type of the converter
- */
-final class MethodConstructorStringConverter<T> extends ReflectionStringConverter<T> {
-
- /** Conversion from a string. */
- private final Constructor<T> fromString;
-
- /**
- * Creates an instance using a method and a constructor.
- * @param cls the class this converts for, not null
- * @param toString the toString method, not null
- * @param fromString the fromString method, not null
- * @throws RuntimeException (or subclass) if the method signatures are invalid
- */
- MethodConstructorStringConverter(Class<T> cls, Method toString, Constructor<T> fromString) {
- super(cls, toString);
- if (cls.isInterface() || Modifier.isAbstract(cls.getModifiers()) || cls.isLocalClass() || cls.isMemberClass()) {
- throw new IllegalArgumentException("FromString constructor must be on an instantiable class: " + fromString);
- }
- if (fromString.getDeclaringClass() != cls) {
- throw new IllegalStateException("FromString constructor must be defined on specified class: " + fromString);
- }
- this.fromString = fromString;
- }
-
- //-----------------------------------------------------------------------
- /**
- * Converts the {@code String} to an object.
- * @param cls the class to convert to, not null
- * @param str the string to convert, not null
- * @return the converted object, may be null but generally not
- */
- @Override
- public T convertFromString(Class<? extends T> cls, String str) {
- try {
- return fromString.newInstance(str);
- } catch (IllegalAccessException ex) {
- throw new IllegalStateException("Constructor is not accessible: " + fromString);
- } catch (InstantiationException ex) {
- throw new IllegalStateException("Constructor is not valid: " + fromString);
- } catch (InvocationTargetException ex) {
- if (ex.getCause() instanceof RuntimeException) {
- throw (RuntimeException) ex.getCause();
- }
- throw new RuntimeException(ex.getMessage(), ex.getCause());
- }
- }
-
- //-------------------------------------------------------------------------
- @Override
- public Class<?> getEffectiveType() {
- return fromString.getDeclaringClass();
- }
-
-}

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/MethodsStringConverter.java Deleted

@@ -1,95 +0,0 @@
-/*
- * Copyright 2010-present Stephen Colebourne
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.joda.convert;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-
-/**
- * Conversion to and from a string using two methods.
- * 
- * The toString method must meet the following signature: 
- * {@code String anyName()} on Class T.
- * 
- * The fromString method must meet the following signature: 
- * {@code static T anyName(String)} on any class.
- * 
- * MethodsStringConverter is thread-safe and immutable.
- * 
- * @param <T> the type of the converter
- */
-final class MethodsStringConverter<T> extends ReflectionStringConverter<T> {
-
- /** Conversion from a string. */
- private final Method fromString;
- /** Effective type. */
- private final Class<?> effectiveType;
-
- /**
- * Creates an instance using two methods.
- * @param cls the class this converts for, not null
- * @param toString the toString method, not null
- * @param fromString the fromString method, not null
- * @throws RuntimeException (or subclass) if the method signatures are invalid
- */
- MethodsStringConverter(Class<T> cls, Method toString, Method fromString, Class<?> effectiveType) {
- super(cls, toString);
- if (Modifier.isStatic(fromString.getModifiers()) == false) {
- throw new IllegalStateException("FromString method must be static: " + fromString);
- }
- if (fromString.getParameterTypes().length != 1) {
- throw new IllegalStateException("FromString method must have one parameter: " + fromString);
- }
- Class<?> param = fromString.getParameterTypes()0;
- if (param != String.class && param != CharSequence.class) {
- throw new IllegalStateException("FromString method must take a String or CharSequence: " + fromString);
- }
- if (fromString.getReturnType().isAssignableFrom(cls) == false && cls.isAssignableFrom(fromString.getReturnType()) == false) {
- throw new IllegalStateException("FromString method must return specified class or a supertype: " + fromString);
- }
- this.fromString = fromString;
- this.effectiveType = effectiveType;
- }
-
- //-----------------------------------------------------------------------
- /**
- * Converts the {@code String} to an object.
- * @param cls the class to convert to, not null
- * @param str the string to convert, not null
- * @return the converted object, may be null but generally not
- */
- @Override
- public T convertFromString(Class<? extends T> cls, String str) {
- try {
- return cls.cast(fromString.invoke(null, str));
- } catch (IllegalAccessException ex) {
- throw new IllegalStateException("Method is not accessible: " + fromString);
- } catch (InvocationTargetException ex) {
- if (ex.getCause() instanceof RuntimeException) {
- throw (RuntimeException) ex.getCause();
- }
- throw new RuntimeException(ex.getMessage(), ex.getCause());
- }
- }
-
- //-------------------------------------------------------------------------
- @Override
- public Class<?> getEffectiveType() {
- return effectiveType;
- }
-
-}

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/TypeStringConverter.java Deleted

@@ -1,53 +0,0 @@
-/*
- * Copyright 2010-present Stephen Colebourne
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.joda.convert;
-
-import java.lang.reflect.Type;
-
-import com.google.common.reflect.TypeToken;
-
-/**
- * Parse the string format of Type via Guava TypeToken.
- * 
- * This is loaded by reflection only when Guava is on the classpath.
- * It relies on internal methods in Guava that could change in any release.
- * 
- * This parser is incomplete, but handles common cases.
- * It does not handle union types or multi-dimensional arrays.
- */
-final class TypeStringConverter
- extends AbstractTypeStringConverter
- implements TypedStringConverter<Type> {
-
- TypeStringConverter() {
- }
-
- @Override
- public String convertToString(Type object) {
- return TypeToken.of(object).toString();
- }
-
- @Override
- public Type convertFromString(Class<? extends Type> cls, String str) {
- return parse(str);
- }
-
- @Override
- public Class<?> getEffectiveType() {
- return Type.class;
- }
-
-}

_service:tar_scm:joda-convert-2.2.3.tar.gz/.github/FUNDING.yml Added

_service:tar_scm:joda-convert-2.2.3.tar.gz/.github/SECURITY.md Added

_service:tar_scm:joda-convert-2.2.3.tar.gz/.github/dependabot.yml Added

_service:tar_scm:joda-convert-2.2.3.tar.gz/.github/website.sh Added

_service:tar_scm:joda-convert-2.2.3.tar.gz/.github/workflows Added

_service:tar_scm:joda-convert-2.2.3.tar.gz/.github/workflows/build.yml Added

@@ -0,0 +1,60 @@
+name: Build
+
+on: 
+  push:
+    branches:
+      - '*'
+    tags:
+      - 'v*'
+      - 'website*'
+  pull_request:
+    branches:
+      - 'main'
+  schedule:
+    - cron: '41 19 * * 2'
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    permissions:
+      security-events: write  # for github/codeql-action
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+
+    - name: Set up JDK
+      uses: actions/setup-java@v3
+      with:
+        java-version: 11
+        distribution: 'temurin'
+        cache: 'maven'
+
+    - name: Maven version
+      run: |
+        mkdir -p ./.mvn
+        echo '-e -B -DtrimStackTrace=false' > ./.mvn/maven.config
+        mvn --version
+        mkdir -p target
+
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: java
+    
+    - name: Maven build
+      run: |
+        mvn install site
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+    
+    - name: Website
+      if: github.event_name == 'push' && (startsWith(github.ref, 'refs/tags/website') || startsWith(github.ref, 'refs/tags/v'))
+      env:
+        GITHUB_TOKEN: ${{ secrets.PERSONAL_TOKEN_GH }}
+      run: |
+        chmod +x ./.github/website.sh
+        .github/website.sh

_service:tar_scm:joda-convert-1.9.2.tar.gz/NOTICE.txt -> _service:tar_scm:joda-convert-2.2.3.tar.gz/NOTICE.txt Changed

@@ -1,5 +1,20 @@
-=============================================================================
-= NOTICE file corresponding to section 4d of the Apache License Version 2.0 =
-=============================================================================
+Joda Convert
+Copyright 2010-present Stephen Colebourne
+
 This product includes software developed by
-Joda.org (http://www.joda.org/).
+Joda.org (https://www.joda.org/).
+
+
+Joda-Convert includes code from Google Guava, which is licensed as follows:
+
+Copyright (C) 2011 The Guava Authors
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+in compliance with the License. You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License
+is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+or implied. See the License for the specific language governing permissions and limitations under
+the License.

_service:tar_scm:joda-convert-1.9.2.tar.gz/README.md -> _service:tar_scm:joda-convert-2.2.3.tar.gz/README.md Changed

@@ -1,7 +1,8 @@
 Joda-Convert
 ------------
 
-Joda-Convert provides a small set of classes to aid conversion between Objects and Strings.
+Joda-Convert is a small, highly-focussed library(https://www.joda.org/joda-convert/apidocs/org.joda.convert/org/joda/convert/StringConvert.html), tackling a problem that the JDK should solve -
+providing round-trip conversion between Objects and Strings.
 It is not intended to tackle the wider problem of Object to Object transformation.
 
 ```java
@@ -13,13 +14,15 @@
 ```
 
 Joda-Convert supports two mechanisms of extending the list of supported conversions.
-The first is to write your own converter implementing an interface.
+The first is to write your own converter(https://www.joda.org/joda-convert/apidocs/org.joda.convert/org/joda/convert/TypedStringConverter.html) implementing an interface.
 The second is to use annotations.
 
 The ability of Joda-Convert to use annotations to define the conversion methods is a key difference from other projects.
-For example, most value classes, like <code>Currency</code> or <code>TimeZone</code>, already have methods
+For example, most value classes, like `Currency` or `TimeZone`, already have methods
 to convert to and from a standard format String.
-Consider a <code>Distance</code> class:
+Consider a `Distance` class annotated with
+`FromString`(https://www.joda.org/joda-convert/apidocs/org.joda.convert/org/joda/convert/FromString.html) and
+`ToString`(https://www.joda.org/joda-convert/apidocs/org.joda.convert/org/joda/convert/ToString.html):
 
 ```java
 public class Distance {
@@ -34,39 +37,59 @@
 ```
 
 As shown, the two methods may have any name. They must simply fulfil the required method signatures for conversion.
-The <code>FromString</code> annotation may also be applied to a constructor.
+The `FromString` annotation may also be applied to a constructor.
 
 When Joda-Convert is asked to convert between an object and a String, if there is no registered converter
 then the annotations are checked. If they are found, then the methods are called by reflection.
 
-Joda-Convert is licensed under the business-friendly Apache 2.0 licence(http://www.joda.org/joda-convert/license.html).
+Joda-Convert is licensed under the business-friendly Apache 2.0 licence(https://www.joda.org/joda-convert/licenses.html).
 
 
 ### Documentation
 Various documentation is available:
 
-* The home page(http://www.joda.org/joda-convert/)
-* The helpful user guide(http://www.joda.org/joda-convert/userguide.html)
-* The Javadoc(http://www.joda.org/joda-convert/apidocs/index.html)
-* The change notes for the releases(http://www.joda.org/joda-convert/changes-report.html)
+* The home page(https://www.joda.org/joda-convert/)
+* The helpful user guide(https://www.joda.org/joda-convert/userguide.html)
+* The Javadoc(https://www.joda.org/joda-convert/apidocs/index.html)
+* The change notes for the releases(https://www.joda.org/joda-convert/changes-report.html)
 
 
 ### Releases
-Release 1.9.2(http://www.joda.org/joda-convert/download.html) is the current latest release.
-This release is considered stable and worthy of the 1.x tag.
+Release 2.2.3(https://www.joda.org/joda-convert/download.html) is the current latest release.
+This release is considered stable and worthy of the 2.x tag.
+The v2.x releases are compatible with v1.x releases, with the exception that the direct Guava dependency is removed.
 It depends on Java SE 6 or later.
 
-Available in the Maven Central repository(http://search.maven.org/#artifactdetails|org.joda|joda-convert|1.9.2|jar)
+Available in the Maven Central repository(https://search.maven.org/search?q=g:org.joda%20AND%20a:joda-convert&core=gav)
+
+!Tidelift dependency check(https://tidelift.com/badges/github/JodaOrg/joda-convert)
+
+
+### For enterprise
+Available as part of the Tidelift Subscription.
+
+Joda and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.
+
+If you want the flexibility of open source and the confidence of commercial-grade software, this is for you.
+
+Learn more(https://tidelift.com/subscription/pkg/maven-org-joda-joda-convert?utm_source=maven-org-joda-joda-convert&utm_medium=github)
 
 
 ### Support
-Please use GitHub issues and Pull Requests for support.
+Please use Stack Overflow(https://stackoverflow.com/search?q=joda-convert) for general usage questions.
+GitHub issues(https://github.com/JodaOrg/joda-convert/issues) and pull requests(https://github.com/JodaOrg/joda-convert/pulls)
+should be used when you want to help advance the project.
+
+Any donations to support the project are accepted via OpenCollective(https://opencollective.com/joda).
+
+To report a security vulnerability, please use the Tidelift security contact(https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
 
 
 ### Release process
 
-* Update version (pom.xml, README.md, index.md, changes.xml)
+* Update version (README.md, index.md, changes.xml)
 * Commit and push
-* `mvn clean deploy -Doss.repo -Dgpg.passphrase=""`
-* Release project in Nexus(https://oss.sonatype.org)
-* Website will be built and released by Travis
+* `mvn clean release:clean release:prepare release:perform`
+* `git fetch`
+* Website will be built and released by GitHub Actions

_service:tar_scm:joda-convert-1.9.2.tar.gz/RELEASE-NOTES.txt -> _service:tar_scm:joda-convert-2.2.3.tar.gz/RELEASE-NOTES.txt Changed

_service:tar_scm:joda-convert-1.9.2.tar.gz/pom.xml -> _service:tar_scm:joda-convert-2.2.3.tar.gz/pom.xml Changed

@@ -1,24 +1,41 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project
- xmlns="http://maven.apache.org/POM/4.0.0"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 
+ 
+ 
+ 
 <modelVersion>4.0.0</modelVersion>
 <groupId>org.joda</groupId>
 <artifactId>joda-convert</artifactId>
 <packaging>jar</packaging>
 <name>Joda-Convert</name>
- <version>1.9.2</version>
+ <version>2.2.3</version>
 <description>Library to convert Objects to and from String</description>
- <url>http://www.joda.org/joda-convert/</url>
+ <url>https://www.joda.org/joda-convert/</url>
 
 
+ <inceptionYear>2010</inceptionYear>
+ <licenses>
+ <license>
+ <name>Apache License, Version 2.0</name>
+ <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
+ <distribution>repo</distribution>
+ </license>
+ </licenses>
+ <organization>
+ <name>Joda.org</name>
+ <url>https://www.joda.org</url>
+ </organization>
 <issueManagement>
 <system>GitHub</system>
 <url>https://github.com/JodaOrg/joda-convert/issues</url>
 </issueManagement>
- <inceptionYear>2010</inceptionYear>
+ <scm>
+ <connection>scm:git:https://github.com/JodaOrg/joda-convert.git</connection>
+ <developerConnection>scm:git:https://github.com/JodaOrg/joda-convert.git</developerConnection>
+ <url>https://github.com/JodaOrg/joda-convert</url>
+ <tag>v2.2.3</tag>
+ </scm>
 
 
 <developers>
@@ -44,24 +61,6 @@
 </contributors>
 
 
- <licenses>
- <license>
- <name>Apache 2</name>
- <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
- <distribution>repo</distribution>
- </license>
- </licenses>
- <scm>
- <connection>scm:git:https://github.com/JodaOrg/joda-convert.git</connection>
- <developerConnection>scm:git:git@github.com:JodaOrg/joda-convert.git</developerConnection>
- <url>https://github.com/JodaOrg/joda-convert</url>
- </scm>
- <organization>
- <name>Joda.org</name>
- <url>http://www.joda.org</url>
- </organization>
-
- 
 <build>
 <resources>
 <resource>
@@ -78,31 +77,87 @@
 </resources>
 
 <plugins>
+ 
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-checkstyle-plugin</artifactId>
+ <artifactId>maven-enforcer-plugin</artifactId>
 <executions>
 <execution>
- <id>run-checkstyle</id>
- <phase>process-sources</phase>
+ <id>enforce-maven</id>
 <goals>
- <goal>checkstyle</goal>
+ <goal>enforce</goal>
 </goals>
+ <configuration>
+ <rules>
+ <requireMavenVersion>
+ <version>3.6.0</version>
+ </requireMavenVersion>
+ <requireJavaVersion>
+ <version>11,)</version>
+ </requireJavaVersion>
+ </rules>
+ </configuration>
 </execution>
 </executions>
 </plugin>
+ 
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
+ <artifactId>maven-compiler-plugin</artifactId>
 <executions>
- 
+ 
+ <execution>
+ <id>default-compile</id>
+ <configuration>
+ <release>9</release>
+ </configuration>
+ </execution>
+ 
 <execution>
- <id>default-test</id>
+ <id>base-compile</id>
 <goals>
- <goal>test</goal>
+ <goal>compile</goal>
 </goals>
- <phase>test</phase>
+ <configuration>
+ <excludes>
+ <exclude>module-info.java</exclude>
+ </excludes>
+ </configuration>
+ </execution>
+ </executions>
+ 
+ <configuration>
+ <release>8</release>
+ </configuration>
+ </plugin>
+ 
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-dependency-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>copy-dependencies</id>
+ <phase>compile</phase>
+ <goals>
+ <goal>copy-dependencies</goal>
+ </goals>
+ <configuration>
+ <outputDirectory>${project.build.directory}/dependencies</outputDirectory>
+ <overWriteReleases>true</overWriteReleases>
+ <overWriteIfNewer>true</overWriteIfNewer>
+ </configuration>
 </execution>
+ </executions>
+ </plugin>
+ 
+ 
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <configuration>
+ <argLine>--add-modules org.joda.convert --module-path ${project.build.directory}/dependencies ${argLine}</argLine>
+ </configuration>
+ <executions>
 
 <execution>
 <id>no-guava</id>
@@ -128,35 +183,12 @@
 </configuration>
 </execution>
 </executions>
- <configuration>
- <properties>
- <property>
- <name>usedefaultlisteners</name>
- <value>false</value>
- </property>
- </properties>
- </configuration>
- </plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-jar-plugin</artifactId>
- <configuration>
- <archive>
- <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
- <manifest>
- <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
- <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
- </manifest>
- <manifestEntries>
- <Automatic-Module-Name>org.joda.convert</Automatic-Module-Name>
- </manifestEntries>
- </archive>
- </configuration>
 </plugin>

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/changes/changes.xml -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/changes/changes.xml Changed

@@ -7,6 +7,105 @@
 
 <body>
 
+ <release version="2.2.3" date="2023-01-15" description="Version 2.2.3">
+ <action dev="jodastephen" type="add">
+ Support classes that define `@FromString` but not `@ToString`.
+ This can be used to leniently parse classes where the format used to be a Joda-Convert class.
+ </action>
+ <action dev="jodastephen" type="update">
+ Switch LGTM to CodeQL.
+ </action>
+ </release>
+ <release version="2.2.2" date="2021-12-15" description="Version 2.2.2">
+ <action dev="jodastephen" type="fix">
+ Fix deserialization of array classes.
+ Fixes #30
+ </action>
+ <action dev="jodastephen" type="update">
+ Switch master to main.
+ </action>
+ </release>
+ <release version="2.2.1" date="2019-04-29" description="Version 2.2.1">
+ <action dev="jodastephen" type="fix">
+ Ensure `ZoneRegion` is correctly converted.
+ </action>
+ </release>
+ <release version="2.2.0" date="2019-01-16" description="Version 2.2.0">
+ <action dev="jodastephen" type="add">
+ Avoid circular loops in dynamic registration of converters.
+ </action>
+ <action dev="jodastephen" type="add">
+ Optimise dynamic registration of converters.
+ </action>
+ <action dev="jodastephen" type="add">
+ Add Tidelift commercial support and security policy.
+ </action>
+ </release>
+ <release version="2.1.2" date="2018-10-23" description="Version 2.1.2">
+ <action dev="jodastephen" type="fix">
+ Fix `Renamed.ini` to avoid NPE during loading.
+ A null `RenameHandler.INSTANCE` could be observed if `Renamed.ini` referred to a class
+ with a static initializer that referred back to `RenameHandler`.
+ </action>
+ <action dev="jodastephen" type="fix">
+ Fix build to work on Java 11.
+ </action>
+ </release>
+ <release version="2.1.1" date="2018-07-10" description="Version 2.1.1">
+ <action dev="jodastephen" type="add">
+ Log startup issues when using renames by configuration.
+ </action>
+ </release>
+ <release version="2.1" date="2018-06-08" description="Version 2.1">
+ <action dev="jodastephen" type="add">
+ Register renames by configuration.
+ Add `Renamed.ini` to configure renames more cleanly.
+ Fixes #26.
+ </action>
+ </release>
+ <release version="2.0.2" date="2018-05-30" description="Version 2.0.2">
+ <action dev="jodastephen" type="add">
+ Enhance speed of numeric array parsing.
+ Previous version used regex patterns, which were slower.
+ </action>
+ </release>
+ <release version="2.0.1" date="2018-03-12" description="Version 2.0.1">
+ <action dev="jodastephen" type="add">
+ Add "classic" variant for systems that can't handle module-info.class.
+ </action>
+ </release>
+ <release version="2.0" date="2018-02-15" description="Version 2.0">
+ <action dev="jodastephen" type="add">
+ Add module-info for Java 9.
+ Fixes #21.
+ </action>
+ <action dev="jodastephen" type="add">
+ Update and redesign build to support Java 9.
+ </action>
+ <action dev="jodastephen" type="add" >
+ Remove direct dependency on Guava by copying code into Joda-Convert.
+ The code previously used reflection setAccessible() which would not work on Java 9.
+ The best alternative was to copy (shaded) the relevant part of Guava (same license).
+ This also allowed the converter for `Type` to work without Guava.
+ Given all this, Joda-Convert no longer has an optional dependency on Guava.
+ It will still adapt and setup a converter for `TypeToken` if Guava is present.
+ This adaptation will also work on Java 9, provided the modules are loaded in the same layer.
+ Fixes #20, #22.
+ </action>
+ <action dev="jodastephen" type="fix" >
+ Enable build to work on Java 9.
+ </action>
+ <action dev="jodastephen" type="fix" >
+ Dynamic Java 8 code must not extend Guava code.
+ Incorrect setup of reflection-based converters.
+ Fixes #19.
+ </action>
+ <action dev="jodastephen" type="fix" >
+ Avoid bridge and synthetic methods in reflection.
+ If an annotation is copied to the bridge/synthetic method it causes trouble.
+ Fixes #23.
+ </action>
+ </release>
 <release version="1.9.2" date="2017-09-20" description="Version 1.9.2">
 <action dev="jodastephen" type="fix" >
 Standard subclass of `TimeZone` must be explicitly registered.

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/checkstyle/checkstyle.xml -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/checkstyle/checkstyle.xml Changed

@@ -3,9 +3,8 @@
 
 <module name="Checker">
 <property name="severity" value="warning"/>
+ <property name="tabWidth" value="4"/>
 <module name="TreeWalker">
- <property name="tabWidth" value="4"/>
- <module name="FileContentsHolder"/>
 <module name="ConstantName">
 <property name="format" value="^A-ZA-Z0-9*(_A-Z0-9+)*$|^a-za-zA-Z0-9*$"/>
 </module>
@@ -30,13 +29,7 @@
 <property name="scope" value="protected"/>
 </module>
 <module name="JavadocMethod">
- <property name="scope" value="protected"/>
- <property name="allowUndeclaredRTE" value="true"/>
- <property name="allowMissingThrowsTags" value="true"/>
- <property name="allowMissingJavadoc" value="true"/>
- <property name="allowMissingPropertyJavadoc" value="true"/>
- <property name="logLoadErrors" value="true"/>
- <property name="suppressLoadErrors" value="true"/>
+ <property name="accessModifiers" value="public,protected"/>
 </module>
 <module name="JavadocVariable">
 <property name="scope" value="protected"/>
@@ -44,11 +37,6 @@
 <module name="LeftCurly">
 <property name="severity" value="error"/>
 </module>
- <module name="LineLength">
- <property name="ignorePattern" value="^ *\* *^ +$"/>
- <property name="max" value="200"/>
- <property name="tabWidth" value="2"/>
- </module>
 <module name="LocalFinalVariableName"/>
 <module name="LocalVariableName"/>
 <module name="MemberName">
@@ -58,6 +46,9 @@
 <property name="max" value="300"/>
 </module>
 <module name="MethodName"/>
+ <module name="MissingJavadocMethodCheck">
+ <property name="allowMissingPropertyJavadoc" value="true"/>
+ </module>
 <module name="ModifierOrder">
 <property name="severity" value="error"/>
 </module>
@@ -80,7 +71,6 @@
 </module>
 <module name="ParenPad"/>
 <module name="RedundantImport"/>
- <module name="RedundantModifier"/>
 <module name="RightCurly">
 <property name="severity" value="error"/>
 </module>
@@ -119,13 +109,18 @@
 <property name="basicOffset" value="4"/>
 <property name="caseIndent" value="4"/>
 </module>
+ <module name="SuppressWithNearbyCommentFilter">
+ <property name="commentFormat" value="CSIGNORE"/>
+ <property name="checkFormat" value=".*"/>
+ <property name="checkC" value="false"/>
+ </module>
 </module>
 
 <module name="RegexpHeader">
 <property name="header" value="^/\**?\n^ \* Copyright 2010-present Stephen Colebourne"/>
 <property name="fileExtensions" value="java"/>
 </module>
- <module name="SuppressionCommentFilter">
+ <module name="SuppressWithPlainTextCommentFilter">
 <property name="offCommentFormat" value="CSOFF"/>
 <property name="onCommentFormat" value="CSON"/>
 </module>
@@ -134,10 +129,9 @@
 <property name="eachLine" value="true"/>
 <property name="severity" value="error"/>
 </module>
- <module name="NewlineAtEndOfFile"/>
- <module name="SuppressWithNearbyCommentFilter">
- <property name="commentFormat" value="CSIGNORE"/>
- <property name="checkFormat" value=".*"/>
- <property name="checkC" value="false"/>
+ <module name="LineLength">
+ <property name="ignorePattern" value="^ *\* *^ +$"/>
+ <property name="max" value="200"/>
 </module>
+ <module name="NewlineAtEndOfFile"/>
 </module>

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/module-info.java Added

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2010-present Stephen Colebourne
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Joda-Convert provides a small set of classes to aid conversion between Objects and Strings.
+ * 
+ * The {@code StringConvert} class is the main entry point.
+ * <pre>
+ * // conversion to String
+ * String str = StringConvert.INSTANCE.convertToString(foo);
+ * 
+ * // conversion from String
+ * Foo bar = StringConvert.INSTANCE.convertFromString(Foo.class, str);
+ * </pre>
+ */
+module org.joda.convert {
+
+ // no direct dependency on Guava
+ // the code will adapt and add a read edge dynamically if Guava is visible
+ // from the module layer that Joda-Convert is loaded in
+
+ // export all packages
+ exports org.joda.convert;
+ exports org.joda.convert.factory;
+
+}

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/AnnotationStringConverterFactory.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/AnnotationStringConverterFactory.java Changed

@@ -30,7 +30,7 @@
 /**
 * Singleton instance.
 */
- static final StringConverterFactory INSTANCE = new AnnotationStringConverterFactory();
+ static final AnnotationStringConverterFactory INSTANCE = new AnnotationStringConverterFactory();
 
 /**
 * Restricted constructor.
@@ -59,22 +59,48 @@
 * @return the converter, not null
 * @throws RuntimeException if none found
 */
- private <T> StringConverter<T> findAnnotatedConverter(final Class<T> cls) {
+ private <T> StringConverter<T> findAnnotatedConverter(Class<T> cls) {
 Method toString = findToStringMethod(cls); // checks superclasses
 if (toString == null) {
 return null;
 }
- MethodConstructorStringConverter<T> con = findFromStringConstructor(cls, toString);
- MethodsStringConverter<T> mth = findFromStringMethod(cls, toString, con == null); // optionally checks superclasses
- if (con == null && mth == null) {
+ TypedFromStringConverter<T> fromString = findAnnotatedFromStringConverter(cls);
+ if (fromString == null) {
 throw new IllegalStateException("Class annotated with @ToString but not with @FromString: " + cls.getName());
 }
+ return new ReflectionStringConverter<T>(cls, toString, fromString);
+ }
+
+ /**
+ * Finds a from-string converter by type.
+ * 
+ * @param <T> the type of the converter
+ * @param cls the type to lookup, not null
+ * @return the converter, null if not found
+ * @throws RuntimeException (or subclass) if source code is invalid
+ */
+ <T> TypedFromStringConverter<T> findFromStringConverter(Class<T> cls) {
+ return findAnnotatedFromStringConverter(cls); // capture generics
+ }
+
+ /**
+ * Finds a from-string converter.
+ * 
+ * @param <T> the type of the converter
+ * @param cls the class to find a method for, not null
+ * @return the converter, null if not found
+ * @throws RuntimeException if none found
+ */
+ private <T> TypedFromStringConverter<T> findAnnotatedFromStringConverter(Class<T> cls) {
+ TypedFromStringConverter<T> con = findFromStringConstructor(cls);
+ TypedFromStringConverter<T> mth = findFromStringMethod(cls, con == null); // optionally checks superclasses
 if (con != null && mth != null) {
 throw new IllegalStateException("Both method and constructor are annotated with @FromString: " + cls.getName());
 }
 return (con != null ? con : mth);
 }
 
+ //-------------------------------------------------------------------------
 /**
 * Finds the conversion method.
 * 
@@ -89,12 +115,14 @@
 while (loopCls != null && matched == null) {
 Method methods = loopCls.getDeclaredMethods();
 for (Method method : methods) {
- ToString toString = method.getAnnotation(ToString.class);
- if (toString != null) {
- if (matched != null) {
- throw new IllegalStateException("Two methods are annotated with @ToString: " + cls.getName());
+ if (!method.isBridge() && !method.isSynthetic()) {
+ ToString toString = method.getAnnotation(ToString.class);
+ if (toString != null) {
+ if (matched != null) {
+ throw new IllegalStateException("Two methods are annotated with @ToString: " + cls.getName());
+ }
+ matched = method;
 }
- matched = method;
 }
 }
 loopCls = loopCls.getSuperclass();
@@ -104,12 +132,14 @@
 for (Class<?> loopIfc : eliminateEnumSubclass(cls).getInterfaces()) {
 Method methods = loopIfc.getDeclaredMethods();
 for (Method method : methods) {
- ToString toString = method.getAnnotation(ToString.class);
- if (toString != null) {
- if (matched != null) {
- throw new IllegalStateException("Two methods are annotated with @ToString on interfaces: " + cls.getName());
+ if (!method.isBridge() && !method.isSynthetic()) {
+ ToString toString = method.getAnnotation(ToString.class);
+ if (toString != null) {
+ if (matched != null) {
+ throw new IllegalStateException("Two methods are annotated with @ToString on interfaces: " + cls.getName());
+ }
+ matched = method;
 }
- matched = method;
 }
 }
 }
@@ -117,16 +147,16 @@
 return matched;
 }
 
+ //-------------------------------------------------------------------------
 /**
 * Finds the conversion method.
 * 
 * @param <T> the type of the converter
 * @param cls the class to find a method for, not null
- * @param toString the toString method, not null
 * @return the method to call, null means none found
 * @throws RuntimeException if invalid
 */
- private <T> MethodConstructorStringConverter<T> findFromStringConstructor(Class<T> cls, Method toString) {
+ private <T> TypedFromStringConverter<T> findFromStringConstructor(Class<T> cls) {
 Constructor<T> con;
 try {
 con = cls.getDeclaredConstructor(String.class);
@@ -141,25 +171,24 @@
 if (fromString == null) {
 return null;
 }
- return new MethodConstructorStringConverter<T>(cls, toString, con);
+ return new ConstructorFromStringConverter<T>(cls, con);
 }
 
 /**
 * Finds the conversion method.
 * 
 * @param cls the class to find a method for, not null
- * @param toString the toString method, not null
 * @param searchSuperclasses whether to search superclasses
 * @return the method to call, null means not found
 * @throws RuntimeException if invalid
 */
- private <T> MethodsStringConverter<T> findFromStringMethod(Class<T> cls, Method toString, boolean searchSuperclasses) {
+ private <T> TypedFromStringConverter<T> findFromStringMethod(Class<T> cls, boolean searchSuperclasses) {
 // find in superclass hierarchy
 Class<?> loopCls = cls;
 while (loopCls != null) {
 Method fromString = findFromString(loopCls);
 if (fromString != null) {
- return new MethodsStringConverter<T>(cls, toString, fromString, loopCls);
+ return new MethodFromStringConverter<T>(cls, fromString, loopCls);
 }
 if (searchSuperclasses == false) {
 break;
@@ -167,7 +196,7 @@
 loopCls = loopCls.getSuperclass();
 }
 // find in immediate parent interfaces
- MethodsStringConverter<T> matched = null;
+ TypedFromStringConverter<T> matched = null;
 if (searchSuperclasses) {
 for (Class<?> loopIfc : eliminateEnumSubclass(cls).getInterfaces()) {
 Method fromString = findFromString(loopIfc);
@@ -176,7 +205,7 @@
 throw new IllegalStateException("Two different interfaces are annotated with " +
 "@FromString or @FromStringFactory: " + cls.getName());
 }
- matched = new MethodsStringConverter<T>(cls, toString, fromString, loopIfc);
+ matched = new MethodFromStringConverter<T>(cls, fromString, loopIfc);
 }
 }
 }
@@ -196,12 +225,14 @@
 Method methods = cls.getDeclaredMethods();
 Method matched = null;
 for (Method method : methods) {
- FromString fromString = method.getAnnotation(FromString.class);
- if (fromString != null) {
- if (matched != null) {
- throw new IllegalStateException("Two methods are annotated with @FromString: " + cls.getName());
+ if (!method.isBridge() && !method.isSynthetic()) {
+ FromString fromString = method.getAnnotation(FromString.class);
+ if (fromString != null) {
+ if (matched != null) {
+ throw new IllegalStateException("Two methods are annotated with @FromString: " + cls.getName());
+ }
+ matched = method;
 }
- matched = method;
 }
 }
 // check for factory
@@ -212,14 +243,16 @@
 }
 Method factoryMethods = factory.factory().getDeclaredMethods();
 for (Method method : factoryMethods) {
- // handle factory containing multiple FromString for different types
- if (cls.isAssignableFrom(method.getReturnType())) {
- FromString fromString = method.getAnnotation(FromString.class);
- if (fromString != null) {
- if (matched != null) {
- throw new IllegalStateException("Two methods are annotated with @FromString on the factory: " + factory.factory().getName());
+ if (!method.isBridge() && !method.isSynthetic()) {
+ // handle factory containing multiple FromString for different types

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/ConstructorFromStringConverter.java Added

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2010-present Stephen Colebourne
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.joda.convert;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+
+/**
+ * Conversion from a string using a fromString constructor.
+ * 
+ * The fromString constructor must take a single {@code String} parameter.
+ * 
+ * ConstructorFromStringConverter is thread-safe and immutable.
+ * 
+ * @param <T> the type of the converter
+ */
+final class ConstructorFromStringConverter<T> implements TypedFromStringConverter<T> {
+
+ /** Conversion from a string. */
+ private final Constructor<T> fromString;
+
+ /**
+ * Creates an instance using a method and a constructor.
+ * 
+ * @param cls the class this converts for, not null
+ * @param fromString the fromString method, not null
+ * @throws RuntimeException (or subclass) if the method signatures are invalid
+ */
+ ConstructorFromStringConverter(Class<T> cls, Constructor<T> fromString) {
+ if (cls.isInterface() || Modifier.isAbstract(cls.getModifiers()) || cls.isLocalClass() || cls.isMemberClass()) {
+ throw new IllegalArgumentException("FromString constructor must be on an instantiable class: " + fromString);
+ }
+ if (fromString.getDeclaringClass() != cls) {
+ throw new IllegalStateException("FromString constructor must be defined on specified class: " + fromString);
+ }
+ this.fromString = fromString;
+ }
+
+ //-----------------------------------------------------------------------
+ @Override
+ public T convertFromString(Class<? extends T> cls, String str) {
+ try {
+ return fromString.newInstance(str);
+ } catch (IllegalAccessException ex) {
+ throw new IllegalStateException("Constructor is not accessible: " + fromString);
+ } catch (InstantiationException ex) {
+ throw new IllegalStateException("Constructor is not valid: " + fromString);
+ } catch (InvocationTargetException ex) {
+ if (ex.getCause() instanceof RuntimeException) {
+ throw (RuntimeException) ex.getCause();
+ }
+ throw new RuntimeException(ex.getMessage(), ex.getCause());
+ }
+ }
+
+ //-------------------------------------------------------------------------
+ @Override
+ public Class<?> getEffectiveType() {
+ return fromString.getDeclaringClass();
+ }
+
+}

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/EnumStringConverterFactory.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/EnumStringConverterFactory.java Changed

@@ -61,10 +61,10 @@
 }
 
 //-----------------------------------------------------------------------
- final class EnumStringConverter implements TypedStringConverter<Enum<?>> {
- 
+ static final class EnumStringConverter implements TypedStringConverter<Enum<?>> {
+
 private final Class<?> effectiveType;
- 
+
 EnumStringConverter(Class<?> effectiveType) {
 this.effectiveType = effectiveType;
 }
@@ -73,11 +73,13 @@
 public String convertToString(Enum<?> en) {
 return en.name(); // avoid toString() as that can be overridden
 }
+
 @Override
- @SuppressWarnings({ "unchecked", "rawtypes" })
+ @SuppressWarnings({"unchecked", "rawtypes"})
 public Enum<?> convertFromString(Class<? extends Enum<?>> cls, String str) {
 return RenameHandler.INSTANCE.lookupEnum((Class) cls, str);
 }
+
 @Override
 public Class<?> getEffectiveType() {
 return effectiveType;

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/JDKStringConverter.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/JDKStringConverter.java Changed

@@ -83,7 +83,7 @@
 LONG(Long.class) {
 @Override
 public Object convertFromString(Class<?> cls, String str) {
- return new Long(str);
+ return Long.valueOf(str);
 }
 },
 
@@ -93,7 +93,7 @@
 INTEGER(Integer.class) {
 @Override
 public Object convertFromString(Class<?> cls, String str) {
- return new Integer(str);
+ return Integer.valueOf(str);
 }
 },
 
@@ -103,7 +103,7 @@
 SHORT(Short.class) {
 @Override
 public Object convertFromString(Class<?> cls, String str) {
- return new Short(str);
+ return Short.valueOf(str);
 }
 },
 
@@ -113,7 +113,7 @@
 BYTE(Byte.class) {
 @Override
 public Object convertFromString(Class<?> cls, String str) {
- return new Byte(str);
+ return Byte.valueOf(str);
 }
 },
 /**
@@ -138,7 +138,7 @@
 if (str.length() != 1) {
 throw new IllegalArgumentException("Character value must be a string length 1");
 }
- return new Character(str.charAt(0));
+ return Character.valueOf(str.charAt(0));
 }
 },
 /**
@@ -175,7 +175,7 @@
 DOUBLE(Double.class) {
 @Override
 public Object convertFromString(Class<?> cls, String str) {
- return new Double(str);
+ return Double.valueOf(str);
 }
 },
 /**
@@ -184,7 +184,7 @@
 FLOAT(Float.class) {
 @Override
 public Object convertFromString(Class<?> cls, String str) {
- return new Float(str);
+ return Float.valueOf(str);
 }
 },
 /**

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/MethodFromStringConverter.java Added

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2010-present Stephen Colebourne
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.joda.convert;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+/**
+ * Conversion from a string using a static method.
+ * 
+ * The fromString method must meet the following signature: 
+ * {@code static T anyName(String)} on any class.
+ * 
+ * MethodFromStringConverter is thread-safe and immutable.
+ * 
+ * @param <T> the type of the converter
+ */
+final class MethodFromStringConverter<T> implements TypedFromStringConverter<T> {
+
+ /** Conversion from a string. */
+ private final Method fromString;
+ /** Effective type. */
+ private final Class<?> effectiveType;
+
+ /**
+ * Creates an instance using two methods.
+ * 
+ * @param cls the class this converts for, not null
+ * @param fromString the fromString method, not null
+ * @throws RuntimeException (or subclass) if the method signatures are invalid
+ */
+ MethodFromStringConverter(Class<T> cls, Method fromString, Class<?> effectiveType) {
+ if (Modifier.isStatic(fromString.getModifiers()) == false) {
+ throw new IllegalStateException("FromString method must be static: " + fromString);
+ }
+ if (fromString.getParameterTypes().length != 1) {
+ throw new IllegalStateException("FromString method must have one parameter: " + fromString);
+ }
+ Class<?> param = fromString.getParameterTypes()0;
+ if (param != String.class && param != CharSequence.class) {
+ throw new IllegalStateException("FromString method must take a String or CharSequence: " + fromString);
+ }
+ if (fromString.getReturnType().isAssignableFrom(cls) == false && cls.isAssignableFrom(fromString.getReturnType()) == false) {
+ throw new IllegalStateException("FromString method must return specified class or a supertype: " + fromString);
+ }
+ this.fromString = fromString;
+ this.effectiveType = effectiveType;
+ }
+
+ //-----------------------------------------------------------------------
+ @Override
+ public T convertFromString(Class<? extends T> cls, String str) {
+ try {
+ return cls.cast(fromString.invoke(null, str));
+ } catch (IllegalAccessException ex) {
+ throw new IllegalStateException("Method is not accessible: " + fromString);
+ } catch (InvocationTargetException ex) {
+ if (ex.getCause() instanceof RuntimeException) {
+ throw (RuntimeException) ex.getCause();
+ }
+ throw new RuntimeException(ex.getMessage(), ex.getCause());
+ }
+ }
+
+ //-------------------------------------------------------------------------
+ @Override
+ public Class<?> getEffectiveType() {
+ return effectiveType;
+ }
+
+}

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/OptionalDoubleStringConverter.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/OptionalDoubleStringConverter.java Changed

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/OptionalIntStringConverter.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/OptionalIntStringConverter.java Changed

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/OptionalLongStringConverter.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/OptionalLongStringConverter.java Changed

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/ReflectionStringConverter.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/ReflectionStringConverter.java Changed

@@ -28,20 +28,24 @@
 * 
 * @param <T> the type of the converter
 */
-abstract class ReflectionStringConverter<T> implements TypedStringConverter<T> {
+final class ReflectionStringConverter<T> implements TypedStringConverter<T> {
 
 /** The converted class. */
 private final Class<T> cls;
 /** Conversion to a string. */
 private final Method toString;
+ /** Conversion from a string, package-scoped for testing. */
+ final TypedFromStringConverter<T> fromString;
 
 /**
 * Creates an instance using two methods.
- * @param cls the class this converts for, not null
+ * 
+ * @param cls the class this converts for, null creates a from-string converter
 * @param toString the toString method, not null
+ * @param fromString the fromString converter, not null
 * @throws RuntimeException (or subclass) if the method signatures are invalid
 */
- ReflectionStringConverter(Class<T> cls, Method toString) {
+ ReflectionStringConverter(Class<T> cls, Method toString, TypedFromStringConverter<T> fromString) {
 if (toString.getParameterTypes().length != 0) {
 throw new IllegalStateException("ToString method must have no parameters: " + toString);
 }
@@ -50,14 +54,10 @@
 }
 this.cls = cls;
 this.toString = toString;
+ this.fromString = fromString;
 }
 
 //-----------------------------------------------------------------------
- /**
- * Converts the object to a {@code String}.
- * @param object the object to convert, not null
- * @return the converted string, may be null but generally not
- */
 @Override
 public String convertToString(T object) {
 try {
@@ -72,6 +72,16 @@
 }
 }
 
+ @Override
+ public T convertFromString(Class<? extends T> cls, String str) {
+ return fromString.convertFromString(cls, str);
+ }
+
+ @Override
+ public Class<?> getEffectiveType() {
+ return fromString.getEffectiveType();
+ }
+
 //-----------------------------------------------------------------------
 @Override
 public String toString() {

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/RenameHandler.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/RenameHandler.java Changed

@@ -15,8 +15,16 @@
 */
 package org.joda.convert;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -31,6 +39,14 @@
 * RenameHandler.INSTANCE.renamedEnum("CORRECT", Status.VALID);
 * RenameHandler.INSTANCE.renamedEnum("INCORRECT", Status.INVALID);
 * </pre>
+ * From v2.1, renames can be stored on the classpath in configuration files.
+ * The file location is {@code META-INF/org/joda/convert/Renamed.ini}.
+ * All files found in this location are read and processed.
+ * The format has two sections {@code types} and {@code enums}.
+ * The {@code types} section has lines of the format {@code oldClassName = newClassName}.
+ * The {@code enums} section has lines of the format {@code oldEnumConstantName = enumClassName.newEnumConstantName}.
+ * Lines starting with {@code #} are treated as comments.
+ * 
 * The recommended usage is to edit the static singleton before using other classes.
 * Editing a static is acceptable because renames are driven by bytecode which is static.
 * For additional security, an application should lock the rename handler instance
@@ -41,12 +57,43 @@
 * @since 1.6
 */
 public final class RenameHandler {
+ // NOTE!
+ // This class must be loaded after StringConvert to avoid horrid loops in class initialization
 
 /**
+ * Errors in class initialization are hard to debug.
+ * Set -Dorg.joda.convert.debug=true on the command line to add extra logging to System.err
+ * 
+ * NOTE! This also forces {@link StringConvert} to be loaded before calling {@link #createInstance()}
+ * which is vital to avoid horrid ordering issues when loading Renamed.ini classes that
+ * reference {@code StringConvert}.
+ */
+ private static final boolean LOG = StringConvert.LOG;
+ /**
 * A mutable global instance.
 * This is a singleton instance which is mutated.
+ * It will be populated by the contents of the {@code Renamed.ini} configuration files.
 */
- public static final RenameHandler INSTANCE = new RenameHandler();
+ public static final RenameHandler INSTANCE = createInstance();
+
+ // this is a method to aid IDE debugging of class initialization
+ private static RenameHandler createInstance() {
+ // log errors to System.err, as problems in static initializers can be troublesome to diagnose
+ RenameHandler instance = create(false);
+ try {
+ // calling loadFromClasspath() is the best option even though it mutates INSTANCE
+ // only serious errors will be caught here, most errors will log from parseRenameFile()
+ instance.loadFromClasspath();
+
+ } catch (IllegalStateException ex) {
+ System.err.println("ERROR: " + ex.getMessage());
+ ex.printStackTrace();
+ } catch (Throwable ex) {
+ System.err.println("ERROR: Failed to load Renamed.ini files: " + ex.getMessage());
+ ex.printStackTrace();
+ }
+ return instance;
+ }
 
 /**
 * The lock flag.
@@ -75,6 +122,24 @@
 return new RenameHandler();
 }
 
+ /**
+ * Creates an instance, providing the ability to load types in config files.
+ * 
+ * This is not normally used as the preferred option is to edit the singleton.
+ * 
+ * If the flag is set to true, the classpath config files will be used to register types and enums.
+ * 
+ * @param loadFromClasspath whether to load any types in classpath config files
+ * @return a new instance, not null
+ */
+ public static RenameHandler create(boolean loadFromClasspath) {
+ RenameHandler handler = new RenameHandler();
+ if (loadFromClasspath) {
+ handler.loadFromClasspath();
+ }
+ return handler;
+ }
+
 //-----------------------------------------------------------------------
 /**
 * Restricted constructor.
@@ -129,51 +194,11 @@
 }
 Class<?> type = typeRenames.get(name);
 if (type == null) {
- type = loadType(name);
+ type = StringConvert.loadType(name);
 }
 return type;
 }
 
- /**
- * Loads a type avoiding nulls
- * 
- * @param fullName the full class name
- * @return the loaded class
- * @throws ClassNotFoundException if the class is not found
- */
- Class<?> loadType(String fullName) throws ClassNotFoundException {
- try {
- ClassLoader loader = Thread.currentThread().getContextClassLoader();
- return loader != null ? loader.loadClass(fullName) : Class.forName(fullName);
- } catch (ClassNotFoundException ex) {
- return loadPrimitiveType(fullName, ex);
- }
- }
-
- // handle primitive types
- private Class<?> loadPrimitiveType(String fullName, ClassNotFoundException ex) throws ClassNotFoundException {
- if (fullName.equals("int")) {
- return int.class;
- } else if (fullName.equals("long")) {
- return long.class;
- } else if (fullName.equals("double")) {
- return double.class;
- } else if (fullName.equals("boolean")) {
- return boolean.class;
- } else if (fullName.equals("short")) {
- return short.class;
- } else if (fullName.equals("byte")) {
- return byte.class;
- } else if (fullName.equals("char")) {
- return char.class;
- } else if (fullName.equals("float")) {
- return float.class;
- } else if (fullName.equals("void")) {
- return void.class; 
- }
- throw ex;
- }
-
 //-----------------------------------------------------------------------
 /**
 * Register the fact that an enum constant was renamed.
@@ -274,6 +299,111 @@
 }
 
 //-----------------------------------------------------------------------
+ // loads config files
+ private void loadFromClasspath() {
+ URL url = null;
+ try {
+ // this is the new location of the file, working on Java 8, Java 9 class path and Java 9 module path
+ ClassLoader loader = Thread.currentThread().getContextClassLoader();
+ if (loader == null) {
+ loader = RenameHandler.class.getClassLoader();
+ }
+ if (LOG) {
+ System.err.println("Loading from classpath: " + loader);
+ }
+ Enumeration<URL> en = loader.getResources("META-INF/org/joda/convert/Renamed.ini");
+ while (en.hasMoreElements()) {
+ url = en.nextElement();
+ if (LOG) {
+ System.err.println("Loading file: " + url);
+ }
+ List<String> lines = loadRenameFile(url);
+ parseRenameFile(lines, url);
+ }
+ } catch (Exception ex) {
+ if (LOG) {
+ ex.printStackTrace(System.err);
+ }
+ throw new IllegalStateException("Unable to load Renamed.ini: " + url + ": " + ex.getMessage(), ex);
+ }
+ }
+
+ // loads a single rename file
+ private List<String> loadRenameFile(URL url) throws IOException {
+ List<String> lines = new ArrayList<String>();
+ BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), Charset.forName("UTF-8")));
+ try {
+ String line;
+ while ((line = reader.readLine()) != null) {
+ String trimmed = line.trim();
+ if (!trimmed.isEmpty() && !trimmed.startsWith("#")) {
+ lines.add(trimmed);
+ }
+ }

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/StringConvert.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/StringConvert.java Changed

@@ -41,16 +41,26 @@
 * StringConvert is thread-safe with concurrent caches.
 */
 public final class StringConvert {
+ // NOTE!
+ // There must be no references (direct or indirect) to RenameHandler
+ // This class must be loaded first to avoid horrid loops in class initialization
 
 /**
- * An immutable global instance.
- * 
- * This instance cannot be added to using {@link #register}, however annotated classes
- * are picked up. To register your own converters, simply create an instance of this class.
+ * Errors in class initialization are hard to debug.
+ * Set -Dorg.joda.convert.debug=true on the command line to add extra logging to System.err
 */
- public static final StringConvert INSTANCE = new StringConvert();
+ static final boolean LOG;
+ static {
+ String log = null;
+ try {
+ log = System.getProperty("org.joda.convert.debug");
+ } catch (SecurityException ex) {
+ // ignore
+ }
+ LOG = "true".equalsIgnoreCase(log);
+ }
 /**
- * The cached null object.
+ * The cached null object. Ensure this is above public constants.
 */
 private static final TypedStringConverter<?> CACHED_NULL = new TypedStringConverter<Object>() {
 @Override
@@ -66,6 +76,13 @@
 return null;
 }
 };
+ /**
+ * An immutable global instance.
+ * 
+ * This instance cannot be added to using {@link #register}, however annotated classes
+ * are picked up. To register your own converters, simply create an instance of this class.
+ */
+ public static final StringConvert INSTANCE = new StringConvert();
 
 /**
 * The list of factories.
@@ -75,6 +92,10 @@
 * The cache of converters.
 */
 private final ConcurrentMap<Class<?>, TypedStringConverter<?>> registered = new ConcurrentHashMap<Class<?>, TypedStringConverter<?>>();
+ /**
+ * The cache of from-strings.
+ */
+ private final ConcurrentMap<Class<?>, FromStringConverter<?>> fromStrings = new ConcurrentHashMap<Class<?>, FromStringConverter<?>>();
 
 //-----------------------------------------------------------------------
 /**
@@ -156,57 +177,12 @@
 registered.put(Float.TYPE, JDKStringConverter.FLOAT);
 registered.put(Double.TYPE, JDKStringConverter.DOUBLE);
 registered.put(Character.TYPE, JDKStringConverter.CHARACTER);
- // Guava and Java 8
 tryRegisterGuava();
 tryRegisterJava8Optionals();
 tryRegisterTimeZone();
- // JDK 1.8 classes
- tryRegister("java.time.Instant", "parse");
- tryRegister("java.time.Duration", "parse");
- tryRegister("java.time.LocalDate", "parse");
- tryRegister("java.time.LocalTime", "parse");
- tryRegister("java.time.LocalDateTime", "parse");
- tryRegister("java.time.OffsetTime", "parse");
- tryRegister("java.time.OffsetDateTime", "parse");
- tryRegister("java.time.ZonedDateTime", "parse");
- tryRegister("java.time.Year", "parse");
- tryRegister("java.time.YearMonth", "parse");
- tryRegister("java.time.MonthDay", "parse");
- tryRegister("java.time.Period", "parse");
- tryRegister("java.time.ZoneOffset", "of");
- tryRegister("java.time.ZoneId", "of");
- // ThreeTen backport classes
- tryRegister("org.threeten.bp.Instant", "parse");
- tryRegister("org.threeten.bp.Duration", "parse");
- tryRegister("org.threeten.bp.LocalDate", "parse");
- tryRegister("org.threeten.bp.LocalTime", "parse");
- tryRegister("org.threeten.bp.LocalDateTime", "parse");
- tryRegister("org.threeten.bp.OffsetTime", "parse");
- tryRegister("org.threeten.bp.OffsetDateTime", "parse");
- tryRegister("org.threeten.bp.ZonedDateTime", "parse");
- tryRegister("org.threeten.bp.Year", "parse");
- tryRegister("org.threeten.bp.YearMonth", "parse");
- tryRegister("org.threeten.bp.MonthDay", "parse");
- tryRegister("org.threeten.bp.Period", "parse");
- tryRegister("org.threeten.bp.ZoneOffset", "of");
- tryRegister("org.threeten.bp.ZoneId", "of");
- // Old ThreeTen/JSR-310 classes v0.6.3 and beyond
- tryRegister("javax.time.Instant", "parse");
- tryRegister("javax.time.Duration", "parse");
- tryRegister("javax.time.calendar.LocalDate", "parse");
- tryRegister("javax.time.calendar.LocalTime", "parse");
- tryRegister("javax.time.calendar.LocalDateTime", "parse");
- tryRegister("javax.time.calendar.OffsetDate", "parse");
- tryRegister("javax.time.calendar.OffsetTime", "parse");
- tryRegister("javax.time.calendar.OffsetDateTime", "parse");
- tryRegister("javax.time.calendar.ZonedDateTime", "parse");
- tryRegister("javax.time.calendar.Year", "parse");
- tryRegister("javax.time.calendar.YearMonth", "parse");
- tryRegister("javax.time.calendar.MonthDay", "parse");
- tryRegister("javax.time.calendar.Period", "parse");
- tryRegister("javax.time.calendar.ZoneOffset", "of");
- tryRegister("javax.time.calendar.ZoneId", "of");
- tryRegister("javax.time.calendar.TimeZone", "of");
+ tryRegisterJava8();
+ tryRegisterThreeTenBackport();
+ tryRegisterThreeTenOld();
 }
 if (factories.length > 0) {
 this.factories.addAll(Arrays.asList(factories));
@@ -214,6 +190,7 @@
 this.factories.add(AnnotationStringConverterFactory.INSTANCE);
 if (includeJdkConverters) {
 this.factories.add(EnumStringConverterFactory.INSTANCE);
+ this.factories.add(TypeStringConverterFactory.INSTANCE);
 }
 }
 
@@ -222,21 +199,40 @@
 */
 private void tryRegisterGuava() {
 try {
- RenameHandler.INSTANCE.loadType("com.google.common.reflect.Types");
- @SuppressWarnings("unchecked")
- Class<?> cls = (Class<TypedStringConverter<?>>) RenameHandler.INSTANCE
- .loadType("org.joda.convert.TypeTokenStringConverter");
- TypedStringConverter<?> conv = (TypedStringConverter<?>) cls.newInstance();
- registered.put(conv.getEffectiveType(), conv);
+ // Guava is not a direct dependency, which is significant in the Java 9 module system
+ // to access Guava this module must add a read edge to the module graph
+ // but since this code is written for Java 6, we have to do this by reflection
+ // yuck
+ Class<?> moduleClass = Class.class.getMethod("getModule").getReturnType();
+ Object convertModule = Class.class.getMethod("getModule").invoke(StringConvert.class);
+ Object layer = convertModule.getClass().getMethod("getLayer").invoke(convertModule);
+ if (layer != null) {
+ Object optGuava = layer.getClass().getMethod("findModule", String.class).invoke(layer, "com.google.common");
+ boolean found = (Boolean) optGuava.getClass().getMethod("isPresent").invoke(optGuava);
+ if (found) {
+ Object guavaModule = optGuava.getClass().getMethod("get").invoke(optGuava);
+ moduleClass.getMethod("addReads", moduleClass).invoke(convertModule, guavaModule);
+ }
+ }
 
+ } catch (Throwable ex) {
+ if (LOG) {
+ System.err.println("tryRegisterGuava1: " + ex);
+ }
+ }
+ try {
+ // can now check for Guava
+ // if we have created a read edge, or if we are on the classpath, this will succeed
+ loadType("com.google.common.reflect.TypeToken");
 @SuppressWarnings("unchecked")
- Class<?> cls2 = (Class<TypedStringConverter<?>>) RenameHandler.INSTANCE
- .loadType("org.joda.convert.TypeStringConverter");
- TypedStringConverter<?> conv2 = (TypedStringConverter<?>) cls2.newInstance();
- registered.put(conv2.getEffectiveType(), conv2);
+ Class<?> cls = loadType("org.joda.convert.TypeTokenStringConverter");
+ TypedStringConverter<?> conv = (TypedStringConverter<?>) cls.getDeclaredConstructor().newInstance();
+ registered.put(conv.getEffectiveType(), conv);
 
 } catch (Throwable ex) {
- // ignore
+ if (LOG) {
+ System.err.println("tryRegisterGuava2: " + ex);
+ }
 }
 }
 
@@ -245,27 +241,26 @@
 */
 private void tryRegisterJava8Optionals() {
 try {
- RenameHandler.INSTANCE.loadType("java.util.OptionalInt");
+ loadType("java.util.OptionalInt");
 @SuppressWarnings("unchecked")
- Class<?> cls1 = (Class<TypedStringConverter<?>>) RenameHandler.INSTANCE
- .loadType("org.joda.convert.OptionalIntStringConverter");
- TypedStringConverter<?> conv1 = (TypedStringConverter<?>) cls1.newInstance();
+ Class<?> cls1 = loadType("org.joda.convert.OptionalIntStringConverter");
+ TypedStringConverter<?> conv1 = (TypedStringConverter<?>) cls1.getDeclaredConstructor().newInstance();
 registered.put(conv1.getEffectiveType(), conv1);
 
 @SuppressWarnings("unchecked")
- Class<?> cls2 = (Class<TypedStringConverter<?>>) RenameHandler.INSTANCE
- .loadType("org.joda.convert.OptionalLongStringConverter");
- TypedStringConverter<?> conv2 = (TypedStringConverter<?>) cls2.newInstance();
+ Class<?> cls2 = loadType("org.joda.convert.OptionalLongStringConverter");
+ TypedStringConverter<?> conv2 = (TypedStringConverter<?>) cls2.getDeclaredConstructor().newInstance();
 registered.put(conv2.getEffectiveType(), conv2);

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/TypeCapture.java Added

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-present Stephen Colebourne
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * Copied from Guava and altered. Original copyright:
+ * 
+ * Copyright (C) 2012 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package org.joda.convert;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+/**
+ * Captures the actual type of {@code T}.
+ */
+abstract class TypeCapture<T> {
+
+ /** Returns the captured type. */
+ final Type capture() {
+ Type superclass = getClass().getGenericSuperclass();
+ Types.checkArgument(superclass instanceof ParameterizedType, "%s isn't parameterized", superclass);
+ return ((ParameterizedType) superclass).getActualTypeArguments()0;
+ }
+}

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/TypeStringConverterFactory.java Added

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2010-present Stephen Colebourne
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.joda.convert;
+
+import java.lang.reflect.Type;
+
+/**
+ * Factory for {@code StringConverter} looking up types.
+ * 
+ * This class is immutable and thread-safe.
+ * 
+ * This parses the string format of Type.
+ * 
+ * This is achieved thanks to some code copied from Guava.
+ * (A Guava dependency is painful when building a Java 6 library for Java 9)
+ * 
+ * This parser is incomplete, but handles common cases.
+ * It does not handle union types or multi-dimensional arrays.
+ */
+final class TypeStringConverterFactory
+ implements StringConverterFactory {
+
+ /**
+ * Singleton instance.
+ */
+ static final TypeStringConverterFactory INSTANCE = new TypeStringConverterFactory();
+
+ /**
+ * Restricted constructor.
+ */
+ private TypeStringConverterFactory() {
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Finds a converter by type.
+ * 
+ * @param cls the type to lookup, not null
+ * @return the converter, null if not found
+ * @throws RuntimeException (or subclass) if source code is invalid
+ */
+ @Override
+ public StringConverter<?> findConverter(Class<?> cls) {
+ if (Type.class.isAssignableFrom(cls) && cls != Class.class) {
+ return new TypeStringConverter(cls);
+ }
+ return null;
+ }
+
+ //-----------------------------------------------------------------------
+ @Override
+ public String toString() {
+ return getClass().getSimpleName();
+ }
+
+ //-----------------------------------------------------------------------
+ static final class TypeStringConverter implements TypedStringConverter<Type> {
+
+ private final Class<?> effectiveType;
+
+ TypeStringConverter(Class<?> effectiveType) {
+ this.effectiveType = effectiveType;
+ }
+
+ @Override
+ public String convertToString(Type type) {
+ try {
+ return Types.toString(type);
+ } catch (Exception ex) {
+ return type.toString();
+ }
+ }
+
+ @Override
+ public Type convertFromString(Class<? extends Type> cls, String str) {
+ return TypeUtils.parse(str);
+ }
+
+ @Override
+ public Class<?> getEffectiveType() {
+ return effectiveType;
+ }
+ }
+
+}

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/TypeTokenStringConverter.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/TypeTokenStringConverter.java Changed

@@ -15,7 +15,8 @@
 */
 package org.joda.convert;
 
-import com.google.common.reflect.TypeToken;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
 
 /**
 * Parse the string format of Guava TypeToken.
@@ -27,25 +28,42 @@
 * It does not handle union types or multi-dimensional arrays.
 */
 final class TypeTokenStringConverter
- extends AbstractTypeStringConverter
- implements TypedStringConverter<TypeToken<?>> {
+ implements TypedStringConverter<Object> {
+
+ static final Class<?> TYPE_TOKEN_CLASS;
+ static final Method TYPE_TOKEN_METHOD_OF;
+ static {
+ try {
+ // see StringConvert, which adds the necessary read edge for Java 9
+ TYPE_TOKEN_CLASS = Class.forName("com.google.common.reflect.TypeToken");
+ TYPE_TOKEN_METHOD_OF = TYPE_TOKEN_CLASS.getDeclaredMethod("of", Type.class);
+
+ } catch (Exception ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
 
 TypeTokenStringConverter() {
 }
 
 @Override
- public String convertToString(TypeToken<?> object) {
+ public String convertToString(Object object) {
 return object.toString();
 }
 
 @Override
- public TypeToken<?> convertFromString(Class<? extends TypeToken<?>> cls, String str) {
- return TypeToken.of(parse(str));
+ public Object convertFromString(Class<?> cls, String str) {
+ Type parsed = TypeUtils.parse(str);
+ try {
+ return TYPE_TOKEN_METHOD_OF.invoke(null, parsed);
+ } catch (Exception ex) {
+ throw new IllegalArgumentException(ex);
+ }
 }
 
 @Override
 public Class<?> getEffectiveType() {
- return TypeToken.class;
+ return TYPE_TOKEN_CLASS;
 }
 
 }

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/TypeUtils.java Added

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2010-present Stephen Colebourne
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.joda.convert;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Parse the string format of Guava TypeToken.
+ * 
+ * This is loaded by reflection only when Guava is on the classpath.
+ * It relies on internal methods in Guava that could change in any release.
+ * 
+ * This parser is incomplete, but handles common cases.
+ * It does not handle union types or multi-dimensional arrays.
+ */
+final class TypeUtils {
+
+ // extends
+ private static final String EXTENDS = "? extends ";
+
+ // super
+ private static final String SUPER = "? super ";
+
+ // primitive types
+ private static final Map<String, Class<?>> PRIMITIVES;
+ static {
+ Map<String, Class<?>> map = new HashMap<String, Class<?>>();
+ map.put("byte", byte.class);
+ map.put("short", short.class);
+ map.put("int", int.class);
+ map.put("long", long.class);
+ map.put("boolean", boolean.class);
+ map.put("char", char.class);
+ map.put("float", float.class);
+ map.put("double", double.class);
+ PRIMITIVES = Collections.unmodifiableMap(map);
+ }
+
+ //-----------------------------------------------------------------------
+ // constructor
+ private TypeUtils() {
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Parses the TypeToken string format.
+ * 
+ * @param str the string
+ * @return the token
+ */
+ static Type parse(String str) {
+ try {
+ return doParse(str);
+ } catch (RuntimeException ex) {
+ throw ex;
+ } catch (Exception ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+
+ // parse an element
+ private static Type doParse(String str) throws Exception {
+ Class<?> token = PRIMITIVES.get(str);
+ if (token != null) {
+ return token;
+ }
+ int first = str.indexOf('<');
+ if (first < 0) {
+ return StringConvert.loadType(str);
+ }
+ int last = str.lastIndexOf('>');
+ String baseStr = str.substring(0, first);
+ Class<?> base = StringConvert.loadType(baseStr);
+ String argsStr = str.substring(first + 1, last);
+ List<String> splitArgs = split(argsStr);
+ List<Type> types = new ArrayList<Type>();
+ for (String splitArg : splitArgs) {
+ Type argType;
+ if (splitArg.startsWith(EXTENDS)) {
+ String remainder = splitArg.substring(EXTENDS.length());
+ argType = wildExtendsType(doParse(remainder));
+ } else if (splitArg.startsWith(SUPER)) {
+ String remainder = splitArg.substring(SUPER.length());
+ argType = wildSuperType(doParse(remainder));
+ } else if (splitArg.equals("?")) {
+ argType = wildExtendsType(Object.class);
+ } else if (splitArg.endsWith("")) {
+ String componentStr = splitArg.substring(0, splitArg.length() - 2);
+ Class<?> componentCls = StringConvert.loadType(componentStr);
+ argType = Array.newInstance(componentCls, 0).getClass();
+ } else if (splitArg.startsWith("L") && splitArg.endsWith(";")) {
+ String componentStr = splitArg.substring(2, splitArg.length() - 1);
+ Class<?> componentCls = StringConvert.loadType(componentStr);
+ argType = Array.newInstance(componentCls, 0).getClass();
+ } else {
+ argType = doParse(splitArg);
+ }
+ types.add(argType);
+ }
+ return newParameterizedType(base, types.toArray(new Typetypes.size()));
+ }
+
+ // split by comma, handling nested generified types
+ private static List<String> split(String str) {
+ List<String> result = new ArrayList<String>();
+ int genericCount = 0;
+ int startPos = 0;
+ for (int i = 0; i < str.length(); i++) {
+ if (str.charAt(i) == ',' && genericCount == 0) {
+ result.add(str.substring(startPos, i).trim());
+ startPos = i + 1;
+ } else if (str.charAt(i) == '<') {
+ genericCount++;
+ } else if (str.charAt(i) == '>') {
+ genericCount--;
+ }
+ }
+ result.add(str.substring(startPos).trim());
+ return result;
+ }
+
+ // create a type representing "? extends X"
+ private static Type wildExtendsType(Type bound) throws Exception {
+ return Types.subtypeOf(bound);
+ }
+
+ // create a type representing "? super X"
+ private static Type wildSuperType(Type bound) throws Exception {
+ return Types.supertypeOf(bound);
+ }
+
+ // create a type representing "base<args...>"
+ private static ParameterizedType newParameterizedType(final Class<?> base, Type... args) throws Exception {
+ return Types.newParameterizedType(base, args);
+ }
+
+}

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/TypedFromStringConverter.java Added

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010-present Stephen Colebourne
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.joda.convert;
+
+/**
+ * Interface defining conversion from a {@code String} together with the type.
+ * 
+ * TypedFromStringConverter is an interface and must be implemented with care.
+ * Implementations must be immutable and thread-safe.
+ * 
+ * @param <T> the type of the converter
+ * @since 2.3
+ */
+interface TypedFromStringConverter<T> extends FromStringConverter<T> {
+
+ /**
+ * Gets the effective type that the converter works on.
+ * 
+ * For example, if a class declares the {@code FromString} and {@code ToString}
+ * then the effective type of the converter is that class. If a subclass is
+ * queried for a converter, then the effective type is that of the superclass.
+ * 
+ * @return the effective type
+ */
+ Class<?> getEffectiveType();
+
+}

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/TypedStringConverter.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/TypedStringConverter.java Changed

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/Types.java Added

@@ -0,0 +1,815 @@
+/*
+ * Copyright 2010-present Stephen Colebourne
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * Copied from Guava and altered. Original copyright:
+ * 
+ * Copyright (C) 2011 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package org.joda.convert;
+
+import java.io.Serializable;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.GenericDeclaration;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.security.AccessControlException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * Utilities for working with {@link Type}.
+ */
+final class Types {
+
+ /** Returns the array type of {@code componentType}. */
+ static Type newArrayType(Type componentType) {
+ if (componentType instanceof WildcardType) {
+ WildcardType wildcard = (WildcardType) componentType;
+ Type lowerBounds = wildcard.getLowerBounds();
+ checkArgument(lowerBounds.length <= 1, "Wildcard cannot have more than one lower bounds.");
+ if (lowerBounds.length == 1) {
+ return supertypeOf(newArrayType(lowerBounds0));
+ } else {
+ Type upperBounds = wildcard.getUpperBounds();
+ checkArgument(upperBounds.length == 1, "Wildcard should have only one upper bound.");
+ return subtypeOf(newArrayType(upperBounds0));
+ }
+ }
+ return JavaVersion.CURRENT.newArrayType(componentType);
+ }
+
+ /**
+ * Returns a type where {@code rawType} is parameterized by {@code arguments} and is owned by
+ * {@code ownerType}.
+ */
+ static ParameterizedType newParameterizedTypeWithOwner(
+ Type ownerType, Class<?> rawType, Type... arguments) {
+ if (ownerType == null) {
+ return newParameterizedType(rawType, arguments);
+ }
+ // ParameterizedTypeImpl constructor already checks, but we want to throw NPE before IAE
+ checkNotNull(arguments);
+ checkArgument(rawType.getEnclosingClass() != null, "Owner type for unenclosed %s", rawType);
+ return new ParameterizedTypeImpl(ownerType, rawType, arguments);
+ }
+
+ /**
+ * Returns a type where {@code rawType} is parameterized by {@code arguments}.
+ */
+ static ParameterizedType newParameterizedType(Class<?> rawType, Type... arguments) {
+ return new ParameterizedTypeImpl(
+ ClassOwnership.JVM_BEHAVIOR.getOwnerType(rawType), rawType, arguments);
+ }
+
+ /** Decides what owner type to use for constructing {@link ParameterizedType} from a raw class. */
+ private enum ClassOwnership {
+ OWNED_BY_ENCLOSING_CLASS {
+
+ @Override
+ Class<?> getOwnerType(Class<?> rawType) {
+ return rawType.getEnclosingClass();
+ }
+ },
+ LOCAL_CLASS_HAS_NO_OWNER {
+
+ @Override
+ Class<?> getOwnerType(Class<?> rawType) {
+ if (rawType.isLocalClass()) {
+ return null;
+ } else {
+ return rawType.getEnclosingClass();
+ }
+ }
+ };
+
+ abstract Class<?> getOwnerType(Class<?> rawType);
+
+ static final ClassOwnership JVM_BEHAVIOR = detectJvmBehavior();
+
+ private static ClassOwnership detectJvmBehavior() {
+ class LocalClass<T> {
+ }
+ LocalClass<String> localClass = new LocalClass<String>() {}; // CSIGNORE
+ Class<?> subclass = localClass.getClass();
+ ParameterizedType parameterizedType = (ParameterizedType) subclass.getGenericSuperclass();
+ for (ClassOwnership behavior : ClassOwnership.values()) {
+ if (behavior.getOwnerType(LocalClass.class) == parameterizedType.getOwnerType()) {
+ return behavior;
+ }
+ }
+ throw new AssertionError();
+ }
+ }
+
+ /**
+ * Returns a new {@link TypeVariable} that belongs to {@code declaration} with {@code name} and
+ * {@code bounds}.
+ */
+ static <D extends GenericDeclaration> TypeVariable<D> newArtificialTypeVariable(
+ D declaration, String name, Type... bounds) {
+ return newTypeVariableImpl(
+ declaration, name, (bounds.length == 0) ? new Type {Object.class} : bounds);
+ }
+
+ /** Returns a new {@link WildcardType} with {@code upperBound}. */
+ static WildcardType subtypeOf(Type upperBound) {
+ return new WildcardTypeImpl(new Type0, new Type {upperBound});
+ }
+
+ /** Returns a new {@link WildcardType} with {@code lowerBound}. */
+ static WildcardType supertypeOf(Type lowerBound) {
+ return new WildcardTypeImpl(new Type {lowerBound}, new Type {Object.class});
+ }
+
+ /**
+ * Returns human readable string representation of {@code type}.
+ * <ul>
+ * <li>For array type {@code Foo}, {@code "com.mypackage.Foo"} are returned.
+ * <li>For any class, {@code theClass.getName()} are returned.
+ * <li>For all other types, {@code type.toString()} are returned.
+ * </ul>
+ */
+ static String toString(Type type) {
+ return (type instanceof Class) ? ((Class<?>) type).getName() : type.toString();
+ }
+
+ static Type getComponentType(Type type) {
+ checkNotNull(type);
+ final AtomicReference<Type> result = new AtomicReference<Type>();
+ new TypeVisitor() {
+ @Override
+ void visitTypeVariable(TypeVariable<?> t) {
+ result.set(subtypeOfComponentType(t.getBounds()));
+ }
+
+ @Override
+ void visitWildcardType(WildcardType t) {
+ result.set(subtypeOfComponentType(t.getUpperBounds()));
+ }
+
+ @Override
+ void visitGenericArrayType(GenericArrayType t) {
+ result.set(t.getGenericComponentType());
+ }
+
+ @Override
+ void visitClass(Class<?> t) {
+ result.set(t.getComponentType());
+ }
+ }.visit(type);
+ return result.get();
+ }

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/factory/CharObjectArrayStringConverterFactory.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/factory/CharObjectArrayStringConverterFactory.java Changed

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/factory/NumericArrayStringConverterFactory.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/factory/NumericArrayStringConverterFactory.java Changed

@@ -15,7 +15,7 @@
 */
 package org.joda.convert.factory;
 
-import java.util.regex.Pattern;
+import java.util.Arrays;
 
 import org.joda.convert.StringConverter;
 import org.joda.convert.StringConverterFactory;
@@ -37,10 +37,6 @@
 * Singleton instance.
 */
 public static final StringConverterFactory INSTANCE = new NumericArrayStringConverterFactory();
- /**
- * Delimiter to find.
- */
- static final Pattern DELIMITER = Pattern.compile(",");
 
 /**
 * Restricted constructor.
@@ -104,12 +100,17 @@
 if (str.length() == 0) {
 return EMPTY;
 }
- String split = DELIMITER.split(str);
- long array = new longsplit.length;
- for (int i = 0; i < split.length; i++) {
- arrayi = Long.parseLong(spliti);
+ int count = 0;
+ int base = 0;
+ int sep = str.indexOf(',');
+ long array = new longstr.length() / 2 + 1;
+ while (sep >= 0) {
+ arraycount++ = Long.parseLong(str.substring(base, sep));
+ base = sep + 1;
+ sep = str.indexOf(',', sep + 1);
 }
- return array;
+ arraycount++ = Long.parseLong(str.substring(base, str.length()));
+ return Arrays.copyOf(array, count);
 }
 @Override
 public Class<?> getEffectiveType() {
@@ -139,12 +140,17 @@
 if (str.length() == 0) {
 return EMPTY;
 }
- String split = DELIMITER.split(str);
- int array = new intsplit.length;
- for (int i = 0; i < split.length; i++) {
- arrayi = Integer.parseInt(spliti);
+ int count = 0;
+ int base = 0;
+ int sep = str.indexOf(',');
+ int array = new intstr.length() / 2 + 1;
+ while (sep >= 0) {
+ arraycount++ = Integer.parseInt(str.substring(base, sep));
+ base = sep + 1;
+ sep = str.indexOf(',', sep + 1);
 }
- return array;
+ arraycount++ = Integer.parseInt(str.substring(base, str.length()));
+ return Arrays.copyOf(array, count);
 }
 @Override
 public Class<?> getEffectiveType() {
@@ -174,12 +180,17 @@
 if (str.length() == 0) {
 return EMPTY;
 }
- String split = DELIMITER.split(str);
- short array = new shortsplit.length;
- for (int i = 0; i < split.length; i++) {
- arrayi = Short.parseShort(spliti);
+ int count = 0;
+ int base = 0;
+ int sep = str.indexOf(',');
+ short array = new shortstr.length() / 2 + 1;
+ while (sep >= 0) {
+ arraycount++ = Short.parseShort(str.substring(base, sep));
+ base = sep + 1;
+ sep = str.indexOf(',', sep + 1);
 }
- return array;
+ arraycount++ = Short.parseShort(str.substring(base, str.length()));
+ return Arrays.copyOf(array, count);
 }
 @Override
 public Class<?> getEffectiveType() {
@@ -209,12 +220,17 @@
 if (str.length() == 0) {
 return EMPTY;
 }
- String split = DELIMITER.split(str);
- double array = new doublesplit.length;
- for (int i = 0; i < split.length; i++) {
- arrayi = Double.parseDouble(spliti);
+ int count = 0;
+ int base = 0;
+ int sep = str.indexOf(',');
+ double array = new doublestr.length() / 2 + 1;
+ while (sep >= 0) {
+ arraycount++ = Double.parseDouble(str.substring(base, sep));
+ base = sep + 1;
+ sep = str.indexOf(',', sep + 1);
 }
- return array;
+ arraycount++ = Double.parseDouble(str.substring(base, str.length()));
+ return Arrays.copyOf(array, count);
 }
 @Override
 public Class<?> getEffectiveType() {
@@ -244,12 +260,17 @@
 if (str.length() == 0) {
 return EMPTY;
 }
- String split = DELIMITER.split(str);
- float array = new floatsplit.length;
- for (int i = 0; i < split.length; i++) {
- arrayi = Float.parseFloat(spliti);
+ int count = 0;
+ int base = 0;
+ int sep = str.indexOf(',');
+ float array = new floatstr.length() / 2 + 1;
+ while (sep >= 0) {
+ arraycount++ = Float.parseFloat(str.substring(base, sep));
+ base = sep + 1;
+ sep = str.indexOf(',', sep + 1);
 }
- return array;
+ arraycount++ = Float.parseFloat(str.substring(base, str.length()));
+ return Arrays.copyOf(array, count);
 }
 @Override
 public Class<?> getEffectiveType() {

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/main/java/org/joda/convert/factory/NumericObjectArrayStringConverterFactory.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/main/java/org/joda/convert/factory/NumericObjectArrayStringConverterFactory.java Changed

@@ -15,7 +15,7 @@
 */
 package org.joda.convert.factory;
 
-import java.util.regex.Pattern;
+import java.util.Arrays;
 
 import org.joda.convert.StringConverter;
 import org.joda.convert.StringConverterFactory;
@@ -37,10 +37,6 @@
 * Singleton instance.
 */
 public static final StringConverterFactory INSTANCE = new NumericObjectArrayStringConverterFactory();
- /**
- * Delimiter to find.
- */
- static final Pattern DELIMITER = Pattern.compile(",");
 
 /**
 * Restricted constructor.
@@ -104,14 +100,19 @@
 if (str.length() == 0) {
 return EMPTY;
 }
- String split = DELIMITER.split(str);
- Long array = new Longsplit.length;
- for (int i = 0; i < split.length; i++) {
- if (spliti.equals("-") == false) {
- arrayi = Long.parseLong(spliti);
- }
+ int count = 0;
+ int base = 0;
+ int sep = str.indexOf(',');
+ Long array = new Longstr.length() / 2 + 1;
+ while (sep >= 0) {
+ String split = str.substring(base, sep);
+ arraycount++ = split.equals("-") ? null : Long.valueOf(split);
+ base = sep + 1;
+ sep = str.indexOf(',', sep + 1);
 }
- return array;
+ String split = str.substring(base, str.length());
+ arraycount++ = split.equals("-") ? null : Long.valueOf(split);
+ return Arrays.copyOf(array, count);
 }
 @Override
 public Class<?> getEffectiveType() {
@@ -141,14 +142,19 @@
 if (str.length() == 0) {
 return EMPTY;
 }
- String split = DELIMITER.split(str);
- Integer array = new Integersplit.length;
- for (int i = 0; i < split.length; i++) {
- if (spliti.equals("-") == false) {
- arrayi = Integer.parseInt(spliti);
- }
+ int count = 0;
+ int base = 0;
+ int sep = str.indexOf(',');
+ Integer array = new Integerstr.length() / 2 + 1;
+ while (sep >= 0) {
+ String split = str.substring(base, sep);
+ arraycount++ = split.equals("-") ? null : Integer.valueOf(split);
+ base = sep + 1;
+ sep = str.indexOf(',', sep + 1);
 }
- return array;
+ String split = str.substring(base, str.length());
+ arraycount++ = split.equals("-") ? null : Integer.valueOf(split);
+ return Arrays.copyOf(array, count);
 }
 @Override
 public Class<?> getEffectiveType() {
@@ -178,14 +184,19 @@
 if (str.length() == 0) {
 return EMPTY;
 }
- String split = DELIMITER.split(str);
- Short array = new Shortsplit.length;
- for (int i = 0; i < split.length; i++) {
- if (spliti.equals("-") == false) {
- arrayi = Short.parseShort(spliti);
- }
+ int count = 0;
+ int base = 0;
+ int sep = str.indexOf(',');
+ Short array = new Shortstr.length() / 2 + 1;
+ while (sep >= 0) {
+ String split = str.substring(base, sep);
+ arraycount++ = split.equals("-") ? null : Short.valueOf(split);
+ base = sep + 1;
+ sep = str.indexOf(',', sep + 1);
 }
- return array;
+ String split = str.substring(base, str.length());
+ arraycount++ = split.equals("-") ? null : Short.valueOf(split);
+ return Arrays.copyOf(array, count);
 }
 @Override
 public Class<?> getEffectiveType() {
@@ -215,14 +226,19 @@
 if (str.length() == 0) {
 return EMPTY;
 }
- String split = DELIMITER.split(str);
- Double array = new Doublesplit.length;
- for (int i = 0; i < split.length; i++) {
- if (spliti.equals("-") == false) {
- arrayi = Double.parseDouble(spliti);
- }
+ int count = 0;
+ int base = 0;
+ int sep = str.indexOf(',');
+ Double array = new Doublestr.length() / 2 + 1;
+ while (sep >= 0) {
+ String split = str.substring(base, sep);
+ arraycount++ = split.equals("-") ? null : Double.valueOf(split);
+ base = sep + 1;
+ sep = str.indexOf(',', sep + 1);
 }
- return array;
+ String split = str.substring(base, str.length());
+ arraycount++ = split.equals("-") ? null : Double.valueOf(split);
+ return Arrays.copyOf(array, count);
 }
 @Override
 public Class<?> getEffectiveType() {
@@ -252,14 +268,19 @@
 if (str.length() == 0) {
 return EMPTY;
 }
- String split = DELIMITER.split(str);
- Float array = new Floatsplit.length;
- for (int i = 0; i < split.length; i++) {
- if (spliti.equals("-") == false) {
- arrayi = Float.parseFloat(spliti);
- }
+ int count = 0;
+ int base = 0;
+ int sep = str.indexOf(',');
+ Float array = new Floatstr.length() / 2 + 1;
+ while (sep >= 0) {
+ String split = str.substring(base, sep);
+ arraycount++ = split.equals("-") ? null : Float.valueOf(split);
+ base = sep + 1;
+ sep = str.indexOf(',', sep + 1);
 }
- return array;
+ String split = str.substring(base, str.length());
+ arraycount++ = split.equals("-") ? null : Float.valueOf(split);
+ return Arrays.copyOf(array, count);
 }
 @Override
 public Class<?> getEffectiveType() {

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/site/markdown/enterprise.md Added

@@ -0,0 +1,52 @@
+## Joda-Convert for Enterprise
+
+### Available as part of the Tidelift Subscription
+
+**Tidelift** is working with the maintainers of **Joda-Convert** and thousands of other open source projects to deliver
+commercial support and maintenance for the open source dependencies you use to build your applications. 
+Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use.
+
+<button class="btn-learnmore" type="button">LEARN MORE1</button>
+<button class="btn-requestdemo" type="button">REQUEST A DEMO2</button>
+
+### Enterprise-ready open source software - managed for you
+
+The Tidelift Subscription is a managed open source subscription for application dependencies covering millions
+of open source projects across JavaScript, Python, Java, PHP, Ruby, .NET, and more.
+
+Your subscription includes:
+
+* **Security updates** 
+Tidelift’s security response team coordinates patches for new breaking security vulnerabilities and alerts
+immediately through a private channel, so your software supply chain is always secure.
+
+* **Licensing verification and indemnification** 
+Tidelift verifies license information to enable easy policy enforcement and adds intellectual property
+indemnification to cover creators and users in case something goes wrong. You always have a 100% up-to-date
+bill of materials for your dependencies to share with your legal team, customers, or partners.
+
+* **Maintenance and code improvement** 
+Tidelift ensures the software you rely on keeps working as long as you need it to work.
+Your managed dependencies are actively maintained and we recruit additional maintainers where required.
+
+* **Package selection and version guidance** 
+We help you choose the best open source packages from the start—and then guide you through updates to stay on
+the best releases as new issues arise.
+
+* **Roadmap input** 
+Take a seat at the table with the creators behind the software you use. Tidelift’s participating maintainers
+earn more income as their software is used by more subscribers, so they’re interested in knowing what you need.
+
+* **Tooling and cloud integration** 
+Tidelift works with GitHub, GitLab, BitBucket, and more.
+We support every cloud platform (and other deployment targets, too).
+
+The end result? All of the capabilities you expect from commercial-grade software, for the full breadth
+of open source you use. That means less time grappling with esoteric open source trivia, and more
+time building your own applications—and your business.
+
+<button class="btn-learnmore" type="button">LEARN MORE1</button>
+<button class="btn-requestdemo" type="button">REQUEST A DEMO2</button>
+
+1: https://tidelift.com/subscription/pkg/maven-org-joda-joda-convert?utm_source=maven-org-joda-joda-convert&utm_medium=referral&utm_campaign=enterprise
+2: https://tidelift.com/subscription/request-a-demo?utm_source=maven-org-joda-joda-convert&utm_medium=referral&utm_campaign=enterprise

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/site/markdown/index.md -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/site/markdown/index.md Changed

@@ -7,7 +7,7 @@
 Joda-Convert addresses this without getting caught up in the wider problem
 of Object to Object transformation.
 
-Joda-Convert is licensed under the business-friendly Apache 2.0 licence(license.html).
+Joda-Convert is licensed under the business-friendly Apache 2.0 licence(licenses.html).
 
 
 ## Features
@@ -37,16 +37,16 @@
 Joda-Convert is a small, highly-focussed library, tackling a problem that the JDK should solve -
 providing round-trip conversion between Objects and Strings.
 
-```
+<pre>
 // conversion to String
- String str = StringConvert.INSTANCE.convertToString(foo);
+ String str = <a href="apidocs/org.joda.convert/org/joda/convert/StringConvert.html">StringConvert</a>.INSTANCE.convertToString(foo);
 
 // conversion from String
- Foo bar = StringConvert.INSTANCE.convertFromString(Foo.class, str);
-```
+ Foo bar = StringConvert.INSTANCE.convertFromString(Foo.class, str);
+</pre>
 
 Joda-Convert supports two mechanisms of extending the list of supported conversions.
-The first is to write your own converter implementing an interface.
+The first is to write your own converter(apidocs/org.joda.convert/org/joda/convert/TypedStringConverter.html) implementing an interface.
 The second is to use annotations.
 
 The ability of Joda-Convert to use annotations to define the conversion methods is a key difference from other projects.
@@ -54,19 +54,18 @@
 to convert to and from a standard format String.
 Consider a `Distance` class:
 
-```
- public class Distance {
+<pre>
+ public class Distance {
+ <a href="apidocs/org.joda.convert/org/joda/convert/FromString.html">@FromString</a>
+ public static Distance parse(String str) { ... }
 
- @FromString
- public static Distance parse(String str) { ... }
-
- @ToString
- public String getStandardOutput() { ... }
- }
-```
+ <a href="apidocs/org.joda.convert/org/joda/convert/ToString.html">@ToString</a>
+ public String getStandardOutput() { ... }
+ }
+</pre>
 
 As shown, the two methods may have any name. They must simply fulfil the required method signatures for conversion.
-The <code>FromString</code> annotation may also be applied to a constructor.
+The `FromString` annotation may also be applied to a constructor.
 
 When Joda-Convert is asked to convert between an object and a String, if there is no registered converter
 then the annotations are checked. If they are found, then the methods are called by reflection.
@@ -76,28 +75,56 @@
 
 ## Releases
 
-Release 1.9.2(download.html) is the current latest release.
-This release is considered stable and worthy of the 1.x tag.
+Release 2.2.3(download.html) is the current latest release.
+This release is considered stable and worthy of the 2.x tag.
+The v2.x releases are compatible with v1.x releases, with the exception that the direct Guava dependency is removed.
 
 Joda-Convert requires Java SE 6 or later and has no dependencies(dependencies.html).
 
-Available in Maven Central(http://search.maven.org/#artifactdetails%7Corg.joda%7Cjoda-convert%7C1.9.2%7Cjar).
+Available in Maven Central(https://search.maven.org/search?q=g:org.joda%20AND%20a:joda-convert&core=gav).
 
 ```xml
 <dependency>
 <groupId>org.joda</groupId>
 <artifactId>joda-convert</artifactId>
- <version>1.9.2</version>
+ <version>2.2.3</version>
 </dependency>
 ```
 
+The main jar file is based on Java 6 but contains a `module-info.class` file for Java 9 and later.
+If you have problems with this, there is a "classic" variant you can use instead:
+
+```xml
+<dependency>
+ <groupId>org.joda</groupId>
+ <artifactId>joda-convert</artifactId>
+ <version>2.2.3</version>
+ <classifier>classic</classifier>
+</dependency>
+```
+
+Java module name: `org.joda.convert`.
+
 ---
 
+### For Enterprise
+
+Available as part of the Tidelift Subscription(https://tidelift.com/subscription/pkg/maven-org-joda-joda-money?utm_source=maven-org-joda-joda-money&utm_medium=referral&utm_campaign=enterprise).
+
+Joda and the maintainers of thousands of other packages are working with Tidelift to deliver one
+enterprise subscription that covers all of the open source you use.
+
+If you want the flexibility of open source and the confidence of commercial-grade software, this is for you.
+Learn more(https://tidelift.com/subscription/pkg/maven-org-joda-joda-convert?utm_source=maven-org-joda-joda-convert&utm_medium=referral&utm_campaign=enterprise).
+
+
 ### Support
 
-Support on bugs, library usage or enhancement requests is available on a best efforts basis.
+Please use Stack Overflow(https://stackoverflow.com/search?q=joda-convert) for general usage questions.
+GitHub issues(https://github.com/JodaOrg/joda-convert/issues) and pull requests(https://github.com/JodaOrg/joda-convert/pulls)
+should be used when you want to help advance the project.
 
-To suggest enhancements or contribute, please fork the source code(https://github.com/JodaOrg/joda-convert)
-on GitHub and send a Pull Request.
+Any donations to support the project are accepted via OpenCollective(https://opencollective.com/joda).
 
-Alternatively, use GitHub issues(https://github.com/JodaOrg/joda-convert/issues).
+To report a security vulnerability, please use the Tidelift security contact(https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/site/markdown/userguide.md -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/site/markdown/userguide.md Changed

@@ -7,7 +7,7 @@
 ## Basic usage
 
 Using Joda-Convert is easy at the simplest level.
-The main access is via the class `StringConvert`.
+The main access is via the class `StringConvert`(apidocs/org.joda.convert/org/joda/convert/StringConvert.html).
 
 The easiest way to use the conversion is via the global constant:
 
@@ -90,7 +90,7 @@
 'java.time', 'javax.time' and 'org.threeten.bp'.
 
 Each `StringConvert` instance, other than the global singleton, may have additional converters registered manually.
-Each converter implements the `StringConverter` interface, which is self explanatory.
+Each converter implements the `StringConverter`(apidocs/org.joda.convert/org/joda/convert/StringConverter.html) interface, which is self explanatory.
 
 Converters may also be manually added by method name.
 This is equivalent to using annotations, but suitable when you don't own the code to add them.
@@ -100,7 +100,7 @@
 ## Factories
 
 In addition to manual registration of individual converters, each instance of `StringConvert`
-has a list of factories to use. The `StringConverterFactory` interface defines the factory.
+has a list of factories to use. The `StringConverterFactory`(apidocs/org.joda.convert/org/joda/convert/StringConverterFactory.html) interface defines the factory.
 This allows either bulk registration or dynamic lookup of converters.
 
 A factory is provided to allow numeric arrays to be converted to/from a comma separated list.
@@ -117,7 +117,8 @@
 ## Annotation based conversion
 
 If there is no registered converter for a type, then a search by annotation is performed.
-This will search for the `ToString` and `FromString` annotation on the type.
+This will search for the `ToString`(apidocs/org.joda.convert/org/joda/convert/ToString.html) and
+`FromString`(apidocs/org.joda.convert/org/joda/convert/FromString.html) annotation on the type.
 These annotations will indicate which method should be called to perform the conversion.
 
 ```
@@ -167,7 +168,8 @@
 }
 ```
 
-The `FromStringFactory` annotation points at the factory class that will provide the factory method.
+The `FromStringFactory`(apidocs/org.joda.convert/org/joda/convert/FromStringFactory.html)
+annotation points at the factory class that will provide the factory method.
 Although intended for use with interfaces, it can also be used on the target class or any superclass.
 Note that only the immediate parent interfaces of a class will be searched.
 
@@ -182,7 +184,8 @@
 ## Rename handler
 
 Most large bodies of code will end up renaming classes and enum constants at some point.
-The `RenameHandler` class provides a convenient central place to track this.
+The `RenameHandler`(apidocs/org.joda.convert/org/joda/convert/RenameHandler.html)
+class provides a convenient central place to track this.
 
 If the `RenameHandler` is setup with details of a rename, then an old class name
 or enum constant can be read in and will be automatically converted.
@@ -195,6 +198,11 @@
 The Joda-Convert jar file is not needed by your users unless they want to use conversion.
 If they don't want to use Joda-Convert then the annotations are effectively ignored.
 
-Joda-Time v2.0 and Joda-Money contain these annotations.
-In both cases, the dependency is optional at runtime for users of the projects.
+The following projects are supported by Joda-Convert annotations:
+
+* Joda-Time(https://www.joda.org/joda-time/)
+* Joda-Money(https://www.joda.org/joda-money/)
+* ThreeTen-Extra(https://www.threeten.org/threeten-extra/)
+
+The Joda-Convert dependency is optional at runtime for users of the projects.
 (Note that Scala does not honour the optional behaviour.)

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/site/resources/css/site.css -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/site/resources/css/site.css Changed

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/site/site.xml -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/site/site.xml Changed

@@ -5,9 +5,9 @@
 <googleAnalyticsAccountId>UA-1425975-4</googleAnalyticsAccountId>
 
 <skin>
- <groupId>lt.velykis.maven.skins</groupId>
+ <groupId>org.joda.external</groupId>
 <artifactId>reflow-maven-skin</artifactId>
- <version>1.1.1</version>
+ <version>1.2</version>
 </skin>
 
 <custom>
@@ -21,7 +21,7 @@
 <name>Joda-Convert</name>
 <href>index.html</href>
 </brand>
- <topNav>Documentation|Releases|Development|Joda</topNav>
+ <topNav>Documentation|Releases|Development|Joda|For Enterprise</topNav>
 <bottomNav>
 <column>Documentation</column>
 <column>Releases</column>
@@ -34,6 +34,7 @@
 <toc>false</toc>
 <breadcrumbs>false</breadcrumbs>
 <markPageHeader>false</markPageHeader>
+ <protocolRelativeURLs>true</protocolRelativeURLs>
 <pages>
 <index>
 <sections>
@@ -60,15 +61,16 @@
 
 <body>
 <head>
- <link href="http://netdna.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.css" rel="stylesheet"/>
- <link rel="author" href="https://plus.google.com/113137868744510231215"/>
+ <!CDATA
+ <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.2.0/css/font-awesome.min.css" rel="stylesheet"/>
+ <link rel="author" href="https://plus.google.com/113137868744510231215"/>>
 </head>
 
 <menu name="Documentation">
 <item name="Home" href="index.html"/>
 <item name="User guide" href="userguide.html"/>
 <item name="Javadoc" href="apidocs/index.html"/>
- <item name="License" href="license.html"/>
+ <item name="License" href="licenses.html"/>
 </menu>
 
 <menu name="Releases">
@@ -84,10 +86,14 @@
 </menu>
 
 <menu name="Joda">
- <item name="Home" href="http://www.joda.org"/>
- <item name="Beans" href="http://www.joda.org/joda-beans/"/>
- <item name="Money" href="http://www.joda.org/joda-money/"/>
- <item name="Time" href="http://www.joda.org/joda-time/"/>
+ <item name="Home" href="https://www.joda.org"/>
+ <item name="Beans" href="https://www.joda.org/joda-beans/"/>
+ <item name="Money" href="https://www.joda.org/joda-money/"/>
+ <item name="Time" href="https://www.joda.org/joda-time/"/>
+ </menu>
+
+ <menu name="For Enterprise">
+ <item name="Tidelift" href="enterprise.html"/>
 </menu>
 
 <menu name="Reports" ref="reports"/>

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/test/java/org/joda/convert/DistanceFromStringNoToString.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/java/org/joda/convert/DistanceFromStringNoToString.java Changed

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/java/org/joda/convert/HasCodeImpl.java Added

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-present Stephen Colebourne
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.joda.convert;
+
+/**
+ * A generic implementation, for testing.
+ * There will be a bridge method {@code Object getCode()} in the bytecode as the super-interface is generic.
+ */
+public final class HasCodeImpl implements HasCodeInterface<String> {
+
+ final String code;
+
+ @FromString
+ public HasCodeImpl(String code) {
+ this.code = code;
+ }
+
+ @Override
+ @ToString
+ public String getCode() {
+ return code;
+ }
+
+}

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/java/org/joda/convert/HasCodeInterface.java Added

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/test/java/org/joda/convert/MockIntegerStringConverter.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/java/org/joda/convert/MockIntegerStringConverter.java Changed

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/test/java/org/joda/convert/Status.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/java/org/joda/convert/Status.java Changed

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/test/java/org/joda/convert/TestGuavaTypeTokenStringConverter.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/java/org/joda/convert/TestGuavaTypeTokenStringConverter.java Changed

@@ -17,6 +17,7 @@
 
 import static org.junit.Assert.assertEquals;
 
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.List;
 import java.util.Map;
@@ -75,7 +76,7 @@
 doTest(token, "java.util.List<?>");
 }
 
- @SuppressWarnings({ "unchecked", "rawtypes" })
+ @SuppressWarnings("rawtypes")
 @Test
 public void test_oneArray() {
 TypeToken<?> token = new TypeToken<List<String>>() {};
@@ -160,15 +161,21 @@
 assertEquals(str, test2.convertToString(obj));
 assertEquals(obj, test2.convertFromString(TypeToken.class, str));
 
- TypeStringConverter test3 = new TypeStringConverter();
- assertEquals(Type.class, test3.getEffectiveType());
- assertEquals(str, test3.convertToString(obj.getType()));
- assertEquals(obj.getType(), test3.convertFromString(Type.class, str));
+ TypeStringConverterFactory test3 = TypeStringConverterFactory.INSTANCE;
+ TypedStringConverter<Type> converter3 = (TypedStringConverter<Type>) test3.findConverter(Type.class);
+ assertEquals(Type.class, converter3.getEffectiveType());
+ assertEquals(str, converter3.convertToString(obj.getType()));
+ assertEquals(obj.getType(), converter3.convertFromString(Type.class, str));
 
 TypedStringConverter<Object> test4 = StringConvert.INSTANCE.findTypedConverterNoGenerics(Type.class);
 assertEquals(Type.class, test4.getEffectiveType());
 assertEquals(str, test4.convertToString(obj.getType()));
 assertEquals(obj.getType(), test4.convertFromString(Type.class, str));
+
+ TypedStringConverter<Object> test5 = StringConvert.INSTANCE.findTypedConverterNoGenerics(ParameterizedType.class);
+ assertEquals(ParameterizedType.class, test5.getEffectiveType());
+ assertEquals(str, test5.convertToString(obj.getType()));
+ assertEquals(obj.getType(), test5.convertFromString(ParameterizedType.class, str));
 }
 
 }

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/test/java/org/joda/convert/TestJDKStringConverters.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/java/org/joda/convert/TestJDKStringConverters.java Changed

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/java/org/joda/convert/TestJavaTime.java Added

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-present Stephen Colebourne
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.joda.convert;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+/**
+ * Test java.time.*.
+ */
+public class TestJavaTime {
+
+ @Test
+ public void test_basics() throws ClassNotFoundException {
+ StringConvert test = StringConvert.INSTANCE;
+ // testing on Java 6 so code does not compile
+// assertEquals("2019-06-30", test.convertToString(LocalDate.of(2019, 6, 30)));
+// assertEquals("11:45", test.convertToString(LocalTime.of(11, 45)));
+// assertEquals("2019-06-30T11:45", test.convertToString(LocalDateTime.of(2019, 6, 30, 11, 45)));
+// assertEquals("2019-06-30T11:45+02:00",
+// test.convertToString(OffsetDateTime.of(2019, 6, 30, 11, 45, 0, 0, ZoneOffset.ofHours(2))));
+// assertEquals("2019-06-30T11:45+02:00Europe/Paris",
+// test.convertToString(ZonedDateTime.of(2019, 6, 30, 11, 45, 0, 0, ZoneId.of("Europe/Paris"))));
+// assertEquals("+02:00", test.convertToString(ZoneOffset.ofHours(2)));
+// assertEquals("Europe/Paris", test.convertToString(ZoneId.of("Europe/Paris")));
+// assertEquals(ZoneId.of("Europe/Paris"), test.convertFromString(ZoneId.class, "Europe/Paris"));
+
+ Class<?> zoneIdClass = Class.forName("java.time.ZoneId");
+ assertEquals("Europe/Paris", test.convertFromString(zoneIdClass, "Europe/Paris").toString());
+
+ Class<?> zoneRegionClass = Class.forName("java.time.ZoneRegion");
+ assertEquals("Europe/Paris", test.convertFromString(zoneRegionClass, "Europe/Paris").toString());
+ }
+
+}

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/test/java/org/joda/convert/TestRenameHandler.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/java/org/joda/convert/TestRenameHandler.java Changed

@@ -15,7 +15,14 @@
 */
 package org.joda.convert;
 
-import org.junit.Assert;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.concurrent.atomic.AtomicBoolean;
+
 import org.junit.Test;
 
 /**
@@ -23,12 +30,14 @@
 */
 public class TestRenameHandler {
 
+ static final AtomicBoolean BAD_INIT = new AtomicBoolean();
+
 @Test
 public void test_matchRenamedType() throws ClassNotFoundException {
 RenameHandler test = RenameHandler.create();
 test.renamedType("com.foo.Bar", TestRenameHandler.class);
 Class<?> renamed = test.lookupType("com.foo.Bar");
- Assert.assertEquals(TestRenameHandler.class, renamed);
+ assertEquals(TestRenameHandler.class, renamed);
 }
 
 @Test(expected = ClassNotFoundException.class)
@@ -63,4 +72,30 @@
 test.renamedType("com.foo.Foo", TestRenameHandler.class);
 }
 
+ @Test
+ public void test_matchUsingConfigFile() throws Exception {
+ PrintStream originalErr = System.err;
+ try {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ PrintStream ps = new PrintStream(baos, false, "UTF-8");
+ System.setErr(ps);
+ RenameHandler test = RenameHandler.create(true);
+ System.err.flush();
+ assertEquals(Status.class, test.lookupType("com.foo.Bar"));
+ assertEquals(Status.VALID, test.lookupEnum(Status.class, "YES"));
+ assertEquals(DistanceMethodMethod.class, test.lookupType("com.foo.Foo"));
+ assertEquals(Status.INVALID, test.lookupEnum(Status.class, "NO"));
+ String logged = baos.toString("UTF-8");
+ assertTrue(logged.startsWith("ERROR: Invalid Renamed.ini: "));
+ assertTrue(logged.contains("org.joda.convert.ClassDoesNotExist"));
+ // ensure that the bad init class is loaded, and that it did not see a null RenameHandler
+ assertTrue(test.getTypeRenames().containsKey("com.foo.convert.TestRenameHandlerBadInit"));
+ assertTrue(Status.STRING_CONVERTIBLE);
+ assertFalse(BAD_INIT.get());
+
+ } finally {
+ System.setErr(originalErr);
+ }
+ }
+
 }

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/java/org/joda/convert/TestRenameHandlerBadInit.java Added

_service:tar_scm:joda-convert-1.9.2.tar.gz/src/test/java/org/joda/convert/TestStringConvert.java -> _service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/java/org/joda/convert/TestStringConvert.java Changed

@@ -17,6 +17,7 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -170,7 +171,7 @@
 
 @Test(expected = IllegalArgumentException.class)
 public void test_convertFromString_nullClass() {
- assertEquals(null, StringConvert.INSTANCE.convertFromString(null, "6"));
+ assertNull(StringConvert.INSTANCE.convertFromString(null, "6"));
 }
 
 //-----------------------------------------------------------------------
@@ -219,7 +220,7 @@
 assertEquals("25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(DistanceMethodMethod.class, "25m").amount);
 TypedStringConverter<DistanceMethodMethod> conv = test.findTypedConverter(DistanceMethodMethod.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertSame(conv, test.findConverter(DistanceMethodMethod.class));
 assertEquals(DistanceMethodMethod.class, conv.getEffectiveType());
 assertEquals(true, conv.toString().startsWith("RefectionStringConverter"));
@@ -232,7 +233,7 @@
 assertEquals("25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(DistanceMethodMethodCharSequence.class, "25m").amount);
 TypedStringConverter<DistanceMethodMethodCharSequence> conv = test.findTypedConverter(DistanceMethodMethodCharSequence.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertSame(conv, test.findConverter(DistanceMethodMethodCharSequence.class));
 assertEquals(DistanceMethodMethodCharSequence.class, conv.getEffectiveType());
 assertEquals(true, conv.toString().startsWith("RefectionStringConverter"));
@@ -245,7 +246,7 @@
 assertEquals("25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(DistanceMethodConstructor.class, "25m").amount);
 TypedStringConverter<DistanceMethodConstructor> conv = test.findTypedConverter(DistanceMethodConstructor.class);
- assertEquals(true, conv instanceof MethodConstructorStringConverter<?>);
+ assertFromStringConverter(conv, ConstructorFromStringConverter.class);
 assertSame(conv, test.findConverter(DistanceMethodConstructor.class));
 assertEquals(DistanceMethodConstructor.class, conv.getEffectiveType());
 assertEquals(true, conv.toString().startsWith("RefectionStringConverter"));
@@ -258,20 +259,33 @@
 assertEquals("25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(DistanceMethodConstructorCharSequence.class, "25m").amount);
 TypedStringConverter<DistanceMethodConstructorCharSequence> conv = test.findTypedConverter(DistanceMethodConstructorCharSequence.class);
- assertEquals(true, conv instanceof MethodConstructorStringConverter<?>);
+ assertFromStringConverter(conv, ConstructorFromStringConverter.class);
 assertSame(conv, test.findConverter(DistanceMethodConstructorCharSequence.class));
 assertEquals(DistanceMethodConstructorCharSequence.class, conv.getEffectiveType());
 assertEquals(true, conv.toString().startsWith("RefectionStringConverter"));
 }
 
 @Test
+ public void test_convert_annotationMethodBridgeMethod() {
+ StringConvert test = new StringConvert();
+ HasCodeImpl d = new HasCodeImpl("CODE");
+ assertEquals("CODE", test.convertToString(d));
+ assertEquals(d.code, test.convertFromString(HasCodeImpl.class, "CODE").code);
+ TypedStringConverter<HasCodeImpl> conv = test.findTypedConverter(HasCodeImpl.class);
+ assertFromStringConverter(conv, ConstructorFromStringConverter.class);
+ assertSame(conv, test.findConverter(HasCodeImpl.class));
+ assertEquals(HasCodeImpl.class, conv.getEffectiveType());
+ assertEquals(true, conv.toString().startsWith("RefectionStringConverter"));
+ }
+
+ @Test
 public void test_convert_annotationSubMethodMethod() {
 StringConvert test = new StringConvert();
 SubMethodMethod d = new SubMethodMethod(25);
 assertEquals("25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(SubMethodMethod.class, "25m").amount);
 TypedStringConverter<SubMethodMethod> conv = test.findTypedConverter(SubMethodMethod.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertEquals(SubMethodMethod.class, conv.getEffectiveType());
 assertSame(conv, test.findConverter(SubMethodMethod.class));
 }
@@ -283,7 +297,7 @@
 assertEquals("25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(SubMethodConstructor.class, "25m").amount);
 TypedStringConverter<SubMethodConstructor> conv = test.findTypedConverter(SubMethodConstructor.class);
- assertEquals(true, conv instanceof MethodConstructorStringConverter<?>);
+ assertFromStringConverter(conv, ConstructorFromStringConverter.class);
 assertEquals(SubMethodConstructor.class, conv.getEffectiveType());
 assertSame(conv, test.findConverter(SubMethodConstructor.class));
 }
@@ -295,7 +309,7 @@
 assertEquals("25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(SuperFactorySuper.class, "25m").amount);
 TypedStringConverter<SuperFactorySuper> conv = test.findTypedConverter(SuperFactorySuper.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertEquals(SuperFactorySuper.class, conv.getEffectiveType());
 assertSame(conv, test.findConverter(SuperFactorySuper.class));
 }
@@ -309,7 +323,7 @@
 assertEquals(d.amount, fromStr.amount);
 assertEquals(true, fromStr instanceof SuperFactorySub);
 TypedStringConverter<SuperFactorySub> conv = test.findTypedConverter(SuperFactorySub.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertEquals(SuperFactorySuper.class, conv.getEffectiveType());
 assertSame(conv, test.findConverter(SuperFactorySub.class));
 }
@@ -361,7 +375,7 @@
 assertEquals("25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(DistanceWithFactory.class, "25m").amount);
 TypedStringConverter<DistanceWithFactory> conv = test.findTypedConverter(DistanceWithFactory.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertEquals(DistanceWithFactory.class, conv.getEffectiveType());
 assertSame(conv, test.findConverter(DistanceWithFactory.class));
 assertEquals(true, conv.toString().startsWith("RefectionStringConverter"));
@@ -374,7 +388,7 @@
 assertEquals("25g", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(Test1Class.class, "25g").amount);
 TypedStringConverter<Test1Class> conv = test.findTypedConverter(Test1Class.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertEquals(Test1Class.class, conv.getEffectiveType());
 assertSame(conv, test.findConverter(Test1Class.class));
 assertEquals(true, conv.toString().startsWith("RefectionStringConverter"));
@@ -387,7 +401,7 @@
 assertEquals("25g", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(Test2Class.class, "25g").amount);
 TypedStringConverter<Test2Class> conv = test.findTypedConverter(Test2Class.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertEquals(Test2Interface.class, conv.getEffectiveType());
 assertSame(conv, test.findConverter(Test2Class.class));
 assertEquals(true, conv.toString().startsWith("RefectionStringConverter"));
@@ -400,7 +414,7 @@
 assertEquals("25g", test.convertToString(d));
 assertEquals("25g", test.convertFromString(Test2Interface.class, "25g").print());
 TypedStringConverter<Test2Interface> conv = test.findTypedConverter(Test2Interface.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertEquals(Test2Interface.class, conv.getEffectiveType());
 assertSame(conv, test.findConverter(Test2Interface.class));
 assertEquals(true, conv.toString().startsWith("RefectionStringConverter"));
@@ -413,7 +427,7 @@
 assertEquals("25g", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(Test3Class.class, "25g").amount);
 TypedStringConverter<Test3Class> conv = test.findTypedConverter(Test3Class.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertSame(conv, test.findConverter(Test3Class.class));
 assertEquals(Test3SuperClass.class, conv.getEffectiveType());
 assertEquals(true, conv.toString().startsWith("RefectionStringConverter"));
@@ -512,6 +526,14 @@
 
 //-----------------------------------------------------------------------
 @Test
+ public void test_convertFromString_annotatedFromStringNoToString() {
+ StringConvert test = new StringConvert();
+ DistanceFromStringNoToString result = test.convertFromString(DistanceFromStringNoToString.class, "2m");
+ assertEquals(new DistanceFromStringNoToString(2), result);
+ }
+
+ //-----------------------------------------------------------------------
+ @Test
 public void test_convert_Enum_overrideDefaultWithConverter() {
 StringConvert test = new StringConvert();
 test.register(Validity.class, ValidityStringConverter.INSTANCE);
@@ -608,7 +630,7 @@
 assertEquals("Distance25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(DistanceNoAnnotations.class, "25m").amount);
 StringConverter<DistanceNoAnnotations> conv = test.findConverter(DistanceNoAnnotations.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertSame(conv, test.findConverter(DistanceNoAnnotations.class));
 }
 
@@ -620,7 +642,7 @@
 assertEquals("Distance25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(DistanceNoAnnotationsCharSequence.class, "25m").amount);
 StringConverter<DistanceNoAnnotationsCharSequence> conv = test.findConverter(DistanceNoAnnotationsCharSequence.class);
- assertEquals(true, conv instanceof MethodsStringConverter<?>);
+ assertFromStringConverter(conv, MethodFromStringConverter.class);
 assertSame(conv, test.findConverter(DistanceNoAnnotationsCharSequence.class));
 }
 
@@ -681,7 +703,7 @@
 assertEquals("Distance25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(DistanceNoAnnotationsCharSequence.class, "25m").amount);
 StringConverter<DistanceNoAnnotationsCharSequence> conv = test.findConverter(DistanceNoAnnotationsCharSequence.class);
- assertEquals(true, conv instanceof MethodConstructorStringConverter<?>);
+ assertFromStringConverter(conv, ConstructorFromStringConverter.class);
 assertSame(conv, test.findConverter(DistanceNoAnnotationsCharSequence.class));
 }
 
@@ -693,7 +715,7 @@
 assertEquals("Distance25m", test.convertToString(d));
 assertEquals(d.amount, test.convertFromString(DistanceNoAnnotations.class, "25m").amount);
 StringConverter<DistanceNoAnnotations> conv = test.findConverter(DistanceNoAnnotations.class);
- assertEquals(true, conv instanceof MethodConstructorStringConverter<?>);
+ assertFromStringConverter(conv, ConstructorFromStringConverter.class);

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/resources Added

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/resources/META-INF Added

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/resources/META-INF/org Added

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/resources/META-INF/org/joda Added

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/resources/META-INF/org/joda/convert Added

_service:tar_scm:joda-convert-2.2.3.tar.gz/src/test/resources/META-INF/org/joda/convert/Renamed.ini Added