#477

Committed 04 Apr 2025 05:53PM UTC coverage: 35.124% (-5.1%) from 40.183%

Build # #477

Build Type

push

github

Committed by

aalmiray

Commit Message

fix(deploy): Add missing Forgejo messages

Related to #1842

Coverage Stats

18210 of 51845 relevant lines covered (35.12%)

0.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

42.02

/api/jreleaser-utils/src/main/java/org/jreleaser/util/CollectionUtils.java

/*
 * SPDX-License-Identifier: Apache-2.0
 *
 * Copyright 2020-2025 The JReleaser 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.
 */
package org.jreleaser.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import static java.util.Objects.requireNonNull;

/**
 * <p>Utility class that simplifies creating collections in Java.</p>
 * <p><strong>Creating Maps</strong><br/>
 * <pre>
 * Map&lt;String, Object&gt; m = map()
 *     .e("foo", foo)
 *     .e("bar", bar);
 * </pre></p>
 *
 * <p><strong>Creating Lists</strong><br/>
 * <pre>
 * List&lt;String&gt; l = list()
 *     .e("foo")
 *     .e("bar");
 * </pre></p>
 *
 * <p><strong>Creating Maps</strong><br/>
 * <pre>
 * Set&lt;String&gt; s = set()
 *     .e("foo")
 *     .e("bar");
 * </pre></p>
 *
 * @author Andres Almiray
 * @since 0.1.0
 */
public final class CollectionUtils {
    private static final String ERROR_MAP_NULL = "Argument 'map' must not be null";

    private CollectionUtils() {
        // prevent instantiation
    }

    public static void safePut(String key, Map<String, Object> src, Properties dest) {
        if (src.containsKey(key)) {
            dest.put(key, String.valueOf(src.get(key)));
        }
    }

    public static void safePut(String key, Map<String, Object> src, Properties dest, boolean forceKey) {
        if (src.containsKey(key)) {
            dest.put(key, String.valueOf(src.get(key)));
        } else if (forceKey) {
            dest.put(key, "");
        }
    }

    public static void safePut(String key, Map<String, Object> src, Map<String, Object> dest) {
        if (src.containsKey(key)) {
            dest.put(key, src.get(key));
        }
    }

    public static void safePut(String key, Map<String, Object> src, Map<String, Object> dest, boolean forceKey) {
        if (src.containsKey(key)) {
            dest.put(key, src.get(key));
        } else if (forceKey) {
            dest.put(key, "");
        }
    }

    public static void safePut(String key, Object value, Map<String, Object> dest) {
        if (null != value) {
            dest.put(key, value);
        }
    }

    public static void safePut(String key, Object value, Map<String, Object> dest, boolean forceKey) {
        if (null != value) {
            dest.put(key, value);
        } else if (forceKey) {
            dest.put(key, "");
        }
    }

    public static void safePut(String key, Object value, Properties dest) {
        if (null != value) {
            dest.put(key, value);
        }
    }

    public static <T> boolean intersects(Set<T> s1, Set<T> s2) {
        Set<T> intersection = new LinkedHashSet<>(s1);
        intersection.removeAll(s2);
        return intersection.size() != s1.size();
    }

    public static <T> List<T> reverse(List<T> input) {
        List<T> output = new ArrayList<>(input);
        Collections.reverse(output);
        return output;
    }

    public static <T> List<T> reverse(Collection<T> input) {
        List<T> output = new ArrayList<>(input);
        Collections.reverse(output);
        return output;
    }

    @Deprecated
    @SuppressWarnings({"rawtypes", "unchecked"})
    public static <K, V> Map newMap(Object... keysAndValues) {
        return mapOf(keysAndValues);
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    public static <K, V> Map mapOf(Object... keysAndValues) {
        if (null == keysAndValues) {
            return Collections.emptyMap();
        }
        if (keysAndValues.length % 2 == 1) {
            throw new IllegalArgumentException("Must have an even number of keys and values");
        }

        Map<K, V> map = new HashMap<>();
        for (int i = 0; i < keysAndValues.length; i += 2) {
            map.put((K) keysAndValues[i], (V) keysAndValues[i + 1]);
        }
        return map;
    }

    @Deprecated
    @SafeVarargs
    public static <T> Set<T> newSet(T... values) {
        return setOf(values);
    }

    @SafeVarargs
    public static <T> Set<T> setOf(T... values) {
        if (null == values) {
            return Collections.emptySet();
        }

        return new HashSet<>(Arrays.asList(values));
    }

    @Deprecated
    @SafeVarargs
    public static <T> List<T> newList(T... values) {
        return listOf(values);
    }

    @SafeVarargs
    public static <T> List<T> listOf(T... values) {
        if (null == values) {
            return Collections.emptyList();
        }

        return new ArrayList<>(Arrays.asList(values));
    }

    public static <K, V> MapBuilder<K, V> map() {
        return map(new LinkedHashMap<>());
    }

    public static <K, V> MapBuilder<K, V> map(Map<K, V> delegate) {
        return new MapBuilder<>(delegate);
    }

    public static <E> ListBuilder<E> list() {
        return list(new ArrayList<>());
    }

    public static <E> ListBuilder<E> list(List<E> delegate) {
        return new ListBuilder<>(delegate);
    }

    public static <E> SetBuilder<E> set() {
        return set(new HashSet<>());
    }

    public static <E> SetBuilder<E> set(Set<E> delegate) {
        return new SetBuilder<>(delegate);
    }

    /**
     * Returns an adapted Map as a Properties instance.
     * <p>
     * The Map is used live, which means changes made to it will affect the
     * Properties instance directly.
     *
     * @param map the Map instance to adapt as a Properties instance
     * @return a new Properties instance backed by the supplied Map.
     */
    public static Properties toProperties(Map<String, Object> map) {
        requireNonNull(map, ERROR_MAP_NULL);
        return new MapToPropertiesAdapter(map);
    }

    /**
     * Creates a Properties instances based on the given Map.
     *
     * @param map the Map instance to convert as a Properties instance
     * @return a new Properties instance based by the supplied Map.
     */
    public static Properties toPropertiesDeep(Map<String, Object> map) {
        requireNonNull(map, ERROR_MAP_NULL);
        Properties properties = new Properties();

        for (Map.Entry<String, Object> e : map.entrySet()) {
            createKey(properties, e.getKey(), e.getValue());
        }

        return properties;
    }

    @SuppressWarnings("unchecked")
    private static void createKey(Properties properties, String key, Object value) {
        if (value instanceof Map) {
            Map<String, Object> map = (Map<String, Object>) value;
            for (Map.Entry<String, Object> e : map.entrySet()) {
                createKey(properties, key + "." + e.getKey(), e.getValue());
            }
        } else {
            properties.put(key, value);
        }
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    public static class MapBuilder<K, V> implements Map<K, V> {
        private final Map<K, V> delegate;

        public MapBuilder(Map<K, V> delegate) {
            this.delegate = delegate;
        }

        public MapBuilder<K, V> e(K k, V v) {
            delegate.put(k, v);
            return this;
        }

        @Override
        public int size() {
            return delegate.size();
        }

        @Override
        public boolean isEmpty() {
            return delegate.isEmpty();
        }

        @Override
        public boolean containsKey(Object o) {
            return delegate.containsKey(o);
        }

        @Override
        public boolean containsValue(Object o) {
            return delegate.containsValue(o);
        }

        @Override
        public V get(Object o) {
            return delegate.get(o);
        }

        @Override
        public V put(K k, V v) {
            return delegate.put(k, v);
        }

        @Override
        public V remove(Object o) {
            return delegate.remove(o);
        }

        @Override
        public void putAll(Map<? extends K, ? extends V> map) {
            delegate.putAll(map);
        }

        @Override
        public void clear() {
            delegate.clear();
        }

        @Override
        public Set<K> keySet() {
            return delegate.keySet();
        }

        @Override
        public Collection<V> values() {
            return delegate.values();
        }

        @Override
        public Set<Entry<K, V>> entrySet() {
            return delegate.entrySet();
        }

        @Override
        public boolean equals(Object o) {
            return delegate.equals(o);
        }

        @Override
        public int hashCode() {
            return delegate.hashCode();
        }

        @Override
        public String toString() {
            return delegate.toString();
        }
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    public static class ListBuilder<E> implements List<E> {
        private final List<E> delegate;

        public ListBuilder(List<E> delegate) {
            this.delegate = delegate;
        }

        public ListBuilder<E> e(E e) {
            delegate.add(e);
            return this;
        }

        @Override
        public int size() {
            return delegate.size();
        }

        @Override
        public boolean isEmpty() {
            return delegate.isEmpty();
        }

        @Override
        public boolean contains(Object o) {
            return delegate.contains(o);
        }

        @Override
        public Iterator<E> iterator() {
            return delegate.iterator();
        }

        @Override
        public Object[] toArray() {
            return delegate.toArray();
        }

        @Override
        public <T> T[] toArray(T[] ts) {
            return delegate.toArray(ts);
        }

        @Override
        public boolean add(E e) {
            return delegate.add(e);
        }

        @Override
        public boolean remove(Object o) {
            return delegate.remove(o);
        }

        @Override
        public boolean containsAll(Collection<?> objects) {
            return delegate.containsAll(objects);
        }

        @Override
        public boolean addAll(Collection<? extends E> es) {
            return delegate.addAll(es);
        }

        @Override
        public boolean addAll(int i, Collection<? extends E> es) {
            return delegate.addAll(i, es);
        }

        @Override
        public boolean removeAll(Collection<?> objects) {
            return delegate.removeAll(objects);
        }

        @Override
        public boolean retainAll(Collection<?> objects) {
            return delegate.retainAll(objects);
        }

        @Override
        public void clear() {
            delegate.clear();
        }

        @Override
        public boolean equals(Object o) {
            return delegate.equals(o);
        }

        @Override
        public int hashCode() {
            return delegate.hashCode();
        }

        @Override
        public String toString() {
            return delegate.toString();
        }

        @Override
        public E get(int i) {
            return delegate.get(i);
        }

        @Override
        public E set(int i, E e) {
            return delegate.set(i, e);
        }

        @Override
        public void add(int i, E e) {
            delegate.add(i, e);
        }

        @Override
        public E remove(int i) {
            return delegate.remove(i);
        }

        @Override
        public int indexOf(Object o) {
            return delegate.indexOf(o);
        }

        @Override
        public int lastIndexOf(Object o) {
            return delegate.lastIndexOf(o);
        }

        @Override
        public ListIterator<E> listIterator() {
            return delegate.listIterator();
        }

        @Override
        public ListIterator<E> listIterator(int i) {
            return delegate.listIterator(i);
        }

        @Override
        public List<E> subList(int i, int i1) {
            return delegate.subList(i, i1);
        }
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    public static class SetBuilder<E> implements Set<E> {
        private final Set<E> delegate;

        public SetBuilder(Set<E> delegate) {
            this.delegate = delegate;
        }

        public SetBuilder<E> e(E e) {
            delegate.add(e);
            return this;
        }

        @Override
        public int size() {
            return delegate.size();
        }

        @Override
        public boolean isEmpty() {
            return delegate.isEmpty();
        }

        @Override
        public boolean contains(Object o) {
            return delegate.contains(o);
        }

        @Override
        public Iterator<E> iterator() {
            return delegate.iterator();
        }

        @Override
        public Object[] toArray() {
            return delegate.toArray();
        }

        @Override
        public <T> T[] toArray(T[] ts) {
            return delegate.toArray(ts);
        }

        @Override
        public boolean add(E e) {
            return delegate.add(e);
        }

        @Override
        public boolean remove(Object o) {
            return delegate.remove(o);
        }

        @Override
        public boolean containsAll(Collection<?> objects) {
            return delegate.containsAll(objects);
        }

        @Override
        public boolean addAll(Collection<? extends E> es) {
            return delegate.addAll(es);
        }

        @Override
        public boolean retainAll(Collection<?> objects) {
            return delegate.retainAll(objects);
        }

        @Override
        public boolean removeAll(Collection<?> objects) {
            return delegate.removeAll(objects);
        }

        @Override
        public void clear() {
            delegate.clear();
        }

        @Override
        public boolean equals(Object o) {
            return delegate.equals(o);
        }

        @Override
        public int hashCode() {
            return delegate.hashCode();
        }

        @Override
        public String toString() {
            return delegate.toString();
        }
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    private static class MapToPropertiesAdapter extends Properties {
        private static final long serialVersionUID = -5465075555013344300L;
        private final transient Map<String, Object> map;

        private MapToPropertiesAdapter(Map<String, Object> map) {
            this.map = map;
        }

        @Override
        public synchronized Object setProperty(String key, String value) {
            return map.put(key, value);
        }

        @Override
        public String getProperty(String key) { // lgtm [java/unsynchronized-getter]
            Object value = map.get(key);
            return null != value ? String.valueOf(value) : null;
        }

        @Override
        public String getProperty(String key, String defaultValue) { // lgtm [java/unsynchronized-getter]
            Object value = map.get(key);
            return null != value ? String.valueOf(value) : defaultValue;
        }

        @Override
        public Enumeration<?> propertyNames() {
            return keys();
        }

        @Override
        public Set<String> stringPropertyNames() {
            return map.keySet();
        }

        @Override
        public synchronized int size() {
            return map.size();
        }

        @Override
        public synchronized boolean isEmpty() {
            return map.isEmpty();
        }

        @Override
        public synchronized Enumeration<Object> keys() {
            return new Enumeration<Object>() {
                private final Iterator<String> keys = new ArrayList<>(map.keySet()).iterator();

                @Override
                public boolean hasMoreElements() {
                    return keys.hasNext();
                }

                @Override
                public String nextElement() {
                    return keys.next();
                }
            };
        }

        @Override
        public synchronized Enumeration<Object> elements() {
            return new Enumeration<Object>() {
                private final Iterator<Object> values = new ArrayList<>(map.values()).iterator();

                @Override
                public boolean hasMoreElements() {
                    return values.hasNext();
                }

                @Override
                public Object nextElement() {
                    return values.next();
                }
            };
        }

        @Override
        public synchronized boolean contains(Object value) {
            return map.containsValue(value);
        }

        @Override
        public boolean containsValue(Object value) {
            return map.containsValue(value);
        }

        @Override
        public synchronized boolean containsKey(Object key) {
            return map.containsKey(key);
        }

        @Override
        public synchronized Object get(Object key) {
            return map.get(key);
        }

        @Override
        public synchronized Object put(Object key, Object value) {
            return map.put(String.valueOf(key), value);
        }

        @Override
        public synchronized Object remove(Object key) {
            return map.remove(key);
        }

        @Override
        public synchronized void putAll(Map<?, ?> t) {
            map.putAll((Map<String, Object>) t);
        }

        @Override
        public synchronized void clear() {
            map.clear();
        }

        @Override
        public Set<Object> keySet() {
            return new LinkedHashSet<>(map.keySet());
        }

        @Override
        public Set<Map.Entry<Object, Object>> entrySet() {
            Set<Map.Entry<Object, Object>> set = new LinkedHashSet<>((Set) map.entrySet());
            return new LinkedHashSet<>(set);
        }

        @Override
        public Collection<Object> values() {
            return map.values();
        }

        @Override
        @SuppressWarnings("NoClone")
        public synchronized Object clone() {
            Map<String, Object> m = new LinkedHashMap<>(map);
            return new MapToPropertiesAdapter(m);
        }
    }
}

1	/*
2	* SPDX-License-Identifier: Apache-2.0
3	*
4	* Copyright 2020-2025 The JReleaser authors.
5	*
6	* Licensed under the Apache License, Version 2.0 (the "License");
7	* you may not use this file except in compliance with the License.
8	* You may obtain a copy of the License at
9	*
10	* https://www.apache.org/licenses/LICENSE-2.0
11	*
12	* Unless required by applicable law or agreed to in writing, software
13	* distributed under the License is distributed on an "AS IS" BASIS,
14	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15	* See the License for the specific language governing permissions and
16	* limitations under the License.
17	*/
18	package org.jreleaser.util;
19
20	import java.util.ArrayList;
21	import java.util.Arrays;
22	import java.util.Collection;
23	import java.util.Collections;
24	import java.util.Enumeration;
25	import java.util.HashMap;
26	import java.util.HashSet;
27	import java.util.Iterator;
28	import java.util.LinkedHashMap;
29	import java.util.LinkedHashSet;
30	import java.util.List;
31	import java.util.ListIterator;
32	import java.util.Map;
33	import java.util.Properties;
34	import java.util.Set;
35
36	import static java.util.Objects.requireNonNull;
37
38	/**
39	* <p>Utility class that simplifies creating collections in Java.</p>
40	* <p><strong>Creating Maps</strong><br/>
41	* <pre>
42	* Map<String, Object> m = map()
43	* .e("foo", foo)
44	* .e("bar", bar);
45	* </pre></p>
46	*
47	* <p><strong>Creating Lists</strong><br/>
48	* <pre>
49	* List<String> l = list()
50	* .e("foo")
51	* .e("bar");
52	* </pre></p>
53	*
54	* <p><strong>Creating Maps</strong><br/>
55	* <pre>
56	* Set<String> s = set()
57	* .e("foo")
58	* .e("bar");
59	* </pre></p>
60	*
61	* @author Andres Almiray
62	* @since 0.1.0
63	*/
64	public final class CollectionUtils {
65	private static final String ERROR_MAP_NULL = "Argument 'map' must not be null";
66
67	private CollectionUtils() {
68	// prevent instantiation
69	}
70
71	public static void safePut(String key, Map<String, Object> src, Properties dest) {
72	if (src.containsKey(key)) {	1✔
73	dest.put(key, String.valueOf(src.get(key)));	1✔
74	}
75	}	1✔
76
77	public static void safePut(String key, Map<String, Object> src, Properties dest, boolean forceKey) {
78	if (src.containsKey(key)) {	×
79	dest.put(key, String.valueOf(src.get(key)));	×
80	} else if (forceKey) {	×
81	dest.put(key, "");	×
82	}
83	}	×
84
85	public static void safePut(String key, Map<String, Object> src, Map<String, Object> dest) {
86	if (src.containsKey(key)) {	×
87	dest.put(key, src.get(key));	×
88	}
89	}	×
90
91	public static void safePut(String key, Map<String, Object> src, Map<String, Object> dest, boolean forceKey) {
92	if (src.containsKey(key)) {	×
93	dest.put(key, src.get(key));	×
94	} else if (forceKey) {	×
95	dest.put(key, "");	×
96	}
97	}	×
98
99	public static void safePut(String key, Object value, Map<String, Object> dest) {
100	if (null != value) {	×
101	dest.put(key, value);	×
102	}
103	}	×
104
105	public static void safePut(String key, Object value, Map<String, Object> dest, boolean forceKey) {
106	if (null != value) {	×
107	dest.put(key, value);	×
108	} else if (forceKey) {	×
109	dest.put(key, "");	×
110	}
111	}	×
112
113	public static void safePut(String key, Object value, Properties dest) {
114	if (null != value) {	1✔
115	dest.put(key, value);	1✔
116	}
117	}	1✔
118
119	public static <T> boolean intersects(Set<T> s1, Set<T> s2) {
120	Set<T> intersection = new LinkedHashSet<>(s1);	×
121	intersection.removeAll(s2);	×
122	return intersection.size() != s1.size();	×
123	}
124
125	public static <T> List<T> reverse(List<T> input) {
126	List<T> output = new ArrayList<>(input);	×
127	Collections.reverse(output);	×
128	return output;	×
129	}
130
131	public static <T> List<T> reverse(Collection<T> input) {
132	List<T> output = new ArrayList<>(input);	×
133	Collections.reverse(output);	×
134	return output;	×
135	}
136
137	@Deprecated
138	@SuppressWarnings({"rawtypes", "unchecked"})
139	public static <K, V> Map newMap(Object... keysAndValues) {
140	return mapOf(keysAndValues);	×
141	}
142
143	@SuppressWarnings({"rawtypes", "unchecked"})
144	public static <K, V> Map mapOf(Object... keysAndValues) {
145	if (null == keysAndValues) {	1✔
146	return Collections.emptyMap();	×
147	}
148	if (keysAndValues.length % 2 == 1) {	1✔
149	throw new IllegalArgumentException("Must have an even number of keys and values");	×
150	}
151
152	Map<K, V> map = new HashMap<>();	1✔
153	for (int i = 0; i < keysAndValues.length; i += 2) {	1✔
154	map.put((K) keysAndValues[i], (V) keysAndValues[i + 1]);	1✔
155	}
156	return map;	1✔
157	}
158
159	@Deprecated
160	@SafeVarargs
161	public static <T> Set<T> newSet(T... values) {
162	return setOf(values);	×
163	}
164
165	@SafeVarargs
166	public static <T> Set<T> setOf(T... values) {
167	if (null == values) {	1✔
168	return Collections.emptySet();	×
169	}
170
171	return new HashSet<>(Arrays.asList(values));	1✔
172	}
173
174	@Deprecated
175	@SafeVarargs
176	public static <T> List<T> newList(T... values) {
177	return listOf(values);	×
178	}
179
180	@SafeVarargs
181	public static <T> List<T> listOf(T... values) {
182	if (null == values) {	1✔
183	return Collections.emptyList();	×
184	}
185
186	return new ArrayList<>(Arrays.asList(values));	1✔
187	}
188
189	public static <K, V> MapBuilder<K, V> map() {
190	return map(new LinkedHashMap<>());	1✔
191	}
192
193	public static <K, V> MapBuilder<K, V> map(Map<K, V> delegate) {
194	return new MapBuilder<>(delegate);	1✔
195	}
196
197	public static <E> ListBuilder<E> list() {
198	return list(new ArrayList<>());	×
199	}
200
201	public static <E> ListBuilder<E> list(List<E> delegate) {
202	return new ListBuilder<>(delegate);	1✔
203	}
204
205	public static <E> SetBuilder<E> set() {
206	return set(new HashSet<>());	×
207	}
208
209	public static <E> SetBuilder<E> set(Set<E> delegate) {
210	return new SetBuilder<>(delegate);	1✔
211	}
212
213	/**
214	* Returns an adapted Map as a Properties instance.
215	* <p>
216	* The Map is used live, which means changes made to it will affect the
217	* Properties instance directly.
218	*
219	* @param map the Map instance to adapt as a Properties instance
220	* @return a new Properties instance backed by the supplied Map.
221	*/
222	public static Properties toProperties(Map<String, Object> map) {
223	requireNonNull(map, ERROR_MAP_NULL);	×
224	return new MapToPropertiesAdapter(map);	×
225	}
226
227	/**
228	* Creates a Properties instances based on the given Map.
229	*
230	* @param map the Map instance to convert as a Properties instance
231	* @return a new Properties instance based by the supplied Map.
232	*/
233	public static Properties toPropertiesDeep(Map<String, Object> map) {
234	requireNonNull(map, ERROR_MAP_NULL);	1✔
235	Properties properties = new Properties();	1✔
236
237	for (Map.Entry<String, Object> e : map.entrySet()) {	1✔
238	createKey(properties, e.getKey(), e.getValue());	1✔
239	}	1✔
240
241	return properties;	1✔
242	}
243
244	@SuppressWarnings("unchecked")
245	private static void createKey(Properties properties, String key, Object value) {
246	if (value instanceof Map) {	1✔
247	Map<String, Object> map = (Map<String, Object>) value;	1✔
248	for (Map.Entry<String, Object> e : map.entrySet()) {	1✔
249	createKey(properties, key + "." + e.getKey(), e.getValue());	1✔
250	}	1✔
251	} else {	1✔
252	properties.put(key, value);	1✔
253	}
254	}	1✔
255
256	@SuppressWarnings({"rawtypes", "unchecked"})
257	public static class MapBuilder<K, V> implements Map<K, V> {
258	private final Map<K, V> delegate;
259
260	public MapBuilder(Map<K, V> delegate) {	1✔
261	this.delegate = delegate;	1✔
262	}	1✔
263
264	public MapBuilder<K, V> e(K k, V v) {
265	delegate.put(k, v);	1✔
266	return this;	1✔
267	}
268
269	@Override
270	public int size() {
271	return delegate.size();	1✔
272	}
273
274	@Override
275	public boolean isEmpty() {
276	return delegate.isEmpty();	×
277	}
278
279	@Override
280	public boolean containsKey(Object o) {
281	return delegate.containsKey(o);	1✔
282	}
283
284	@Override
285	public boolean containsValue(Object o) {
286	return delegate.containsValue(o);	1✔
287	}
288
289	@Override
290	public V get(Object o) {
291	return delegate.get(o);	×
292	}
293
294	@Override
295	public V put(K k, V v) {
296	return delegate.put(k, v);	1✔
297	}
298
299	@Override
300	public V remove(Object o) {
301	return delegate.remove(o);	1✔
302	}
303
304	@Override
305	public void putAll(Map<? extends K, ? extends V> map) {
306	delegate.putAll(map);	×
307	}	×
308
309	@Override
310	public void clear() {
311	delegate.clear();	1✔
312	}	1✔
313
314	@Override
315	public Set<K> keySet() {
316	return delegate.keySet();	1✔
317	}
318
319	@Override
320	public Collection<V> values() {
321	return delegate.values();	1✔
322	}
323
324	@Override
325	public Set<Entry<K, V>> entrySet() {
326	return delegate.entrySet();	1✔
327	}
328
329	@Override
330	public boolean equals(Object o) {
331	return delegate.equals(o);	×
332	}
333
334	@Override
335	public int hashCode() {
336	return delegate.hashCode();	1✔
337	}
338
339	@Override
340	public String toString() {
341	return delegate.toString();	×
342	}
343	}
344
345	@SuppressWarnings({"rawtypes", "unchecked"})
346	public static class ListBuilder<E> implements List<E> {
347	private final List<E> delegate;
348
349	public ListBuilder(List<E> delegate) {	1✔
350	this.delegate = delegate;	1✔
351	}	1✔
352
353	public ListBuilder<E> e(E e) {
354	delegate.add(e);	1✔
355	return this;	1✔
356	}
357
358	@Override
359	public int size() {
360	return delegate.size();	1✔
361	}
362
363	@Override
364	public boolean isEmpty() {
365	return delegate.isEmpty();	×
366	}
367
368	@Override
369	public boolean contains(Object o) {
370	return delegate.contains(o);	1✔
371	}
372
373	@Override
374	public Iterator<E> iterator() {
375	return delegate.iterator();	×
376	}
377
378	@Override
379	public Object[] toArray() {
380	return delegate.toArray();	×
381	}
382
383	@Override
384	public <T> T[] toArray(T[] ts) {
385	return delegate.toArray(ts);	×
386	}
387
388	@Override
389	public boolean add(E e) {
390	return delegate.add(e);	1✔
391	}
392
393	@Override
394	public boolean remove(Object o) {
395	return delegate.remove(o);	1✔
396	}
397
398	@Override
399	public boolean containsAll(Collection<?> objects) {
400	return delegate.containsAll(objects);	1✔
401	}
402
403	@Override
404	public boolean addAll(Collection<? extends E> es) {
405	return delegate.addAll(es);	×
406	}
407
408	@Override
409	public boolean addAll(int i, Collection<? extends E> es) {
410	return delegate.addAll(i, es);	×
411	}
412
413	@Override
414	public boolean removeAll(Collection<?> objects) {
415	return delegate.removeAll(objects);	×
416	}
417
418	@Override
419	public boolean retainAll(Collection<?> objects) {
420	return delegate.retainAll(objects);	×
421	}
422
423	@Override
424	public void clear() {
425	delegate.clear();	1✔
426	}	1✔
427
428	@Override
429	public boolean equals(Object o) {
430	return delegate.equals(o);	×
431	}
432
433	@Override
434	public int hashCode() {
435	return delegate.hashCode();	1✔
436	}
437
438	@Override
439	public String toString() {
440	return delegate.toString();	×
441	}
442
443	@Override
444	public E get(int i) {
445	return delegate.get(i);	×
446	}
447
448	@Override
449	public E set(int i, E e) {
450	return delegate.set(i, e);	1✔
451	}
452
453	@Override
454	public void add(int i, E e) {
455	delegate.add(i, e);	1✔
456	}	1✔
457
458	@Override
459	public E remove(int i) {
460	return delegate.remove(i);	×
461	}
462
463	@Override
464	public int indexOf(Object o) {
465	return delegate.indexOf(o);	×
466	}
467
468	@Override
469	public int lastIndexOf(Object o) {
470	return delegate.lastIndexOf(o);	×
471	}
472
473	@Override
474	public ListIterator<E> listIterator() {
475	return delegate.listIterator();	×
476	}
477
478	@Override
479	public ListIterator<E> listIterator(int i) {
480	return delegate.listIterator(i);	×
481	}
482
483	@Override
484	public List<E> subList(int i, int i1) {
485	return delegate.subList(i, i1);	×
486	}
487	}
488
489	@SuppressWarnings({"rawtypes", "unchecked"})
490	public static class SetBuilder<E> implements Set<E> {
491	private final Set<E> delegate;
492
493	public SetBuilder(Set<E> delegate) {	1✔
494	this.delegate = delegate;	1✔
495	}	1✔
496
497	public SetBuilder<E> e(E e) {
498	delegate.add(e);	1✔
499	return this;	1✔
500	}
501
502	@Override
503	public int size() {
504	return delegate.size();	1✔
505	}
506
507	@Override
508	public boolean isEmpty() {
509	return delegate.isEmpty();	×
510	}
511
512	@Override
513	public boolean contains(Object o) {
514	return delegate.contains(o);	1✔
515	}
516
517	@Override
518	public Iterator<E> iterator() {
519	return delegate.iterator();	×
520	}
521
522	@Override
523	public Object[] toArray() {
524	return delegate.toArray();	×
525	}
526
527	@Override
528	public <T> T[] toArray(T[] ts) {
529	return delegate.toArray(ts);	×
530	}
531
532	@Override
533	public boolean add(E e) {
534	return delegate.add(e);	1✔
535	}
536
537	@Override
538	public boolean remove(Object o) {
539	return delegate.remove(o);	1✔
540	}
541
542	@Override
543	public boolean containsAll(Collection<?> objects) {
544	return delegate.containsAll(objects);	1✔
545	}
546
547	@Override
548	public boolean addAll(Collection<? extends E> es) {
549	return delegate.addAll(es);	×
550	}
551
552	@Override
553	public boolean retainAll(Collection<?> objects) {
554	return delegate.retainAll(objects);	×
555	}
556
557	@Override
558	public boolean removeAll(Collection<?> objects) {
559	return delegate.removeAll(objects);	×
560	}
561
562	@Override
563	public void clear() {
564	delegate.clear();	1✔
565	}	1✔
566
567	@Override
568	public boolean equals(Object o) {
569	return delegate.equals(o);	×
570	}
571
572	@Override
573	public int hashCode() {
574	return delegate.hashCode();	1✔
575	}
576
577	@Override
578	public String toString() {
579	return delegate.toString();	×
580	}
581	}
582
583	@SuppressWarnings({"rawtypes", "unchecked"})
584	private static class MapToPropertiesAdapter extends Properties {
585	private static final long serialVersionUID = -5465075555013344300L;
586	private final transient Map<String, Object> map;
587
588	private MapToPropertiesAdapter(Map<String, Object> map) {	×
589	this.map = map;	×
590	}	×
591
592	@Override
593	public synchronized Object setProperty(String key, String value) {
594	return map.put(key, value);	×
595	}
596
597	@Override
598	public String getProperty(String key) { // lgtm [java/unsynchronized-getter]
599	Object value = map.get(key);	×
600	return null != value ? String.valueOf(value) : null;	×
601	}
602
603	@Override
604	public String getProperty(String key, String defaultValue) { // lgtm [java/unsynchronized-getter]
605	Object value = map.get(key);	×
606	return null != value ? String.valueOf(value) : defaultValue;	×
607	}
608
609	@Override
610	public Enumeration<?> propertyNames() {
611	return keys();	×
612	}
613
614	@Override
615	public Set<String> stringPropertyNames() {
616	return map.keySet();	×
617	}
618
619	@Override
620	public synchronized int size() {
621	return map.size();	×
622	}
623
624	@Override
625	public synchronized boolean isEmpty() {
626	return map.isEmpty();	×
627	}
628
629	@Override
630	public synchronized Enumeration<Object> keys() {
631	return new Enumeration<Object>() {	×
632	private final Iterator<String> keys = new ArrayList<>(map.keySet()).iterator();	×
633
634	@Override
635	public boolean hasMoreElements() {
636	return keys.hasNext();	×
637	}
638
639	@Override
640	public String nextElement() {
641	return keys.next();	×
642	}
643	};
644	}
645
646	@Override
647	public synchronized Enumeration<Object> elements() {
648	return new Enumeration<Object>() {	×
649	private final Iterator<Object> values = new ArrayList<>(map.values()).iterator();	×
650
651	@Override
652	public boolean hasMoreElements() {
653	return values.hasNext();	×
654	}
655
656	@Override
657	public Object nextElement() {
658	return values.next();	×
659	}
660	};
661	}
662
663	@Override
664	public synchronized boolean contains(Object value) {
665	return map.containsValue(value);	×
666	}
667
668	@Override
669	public boolean containsValue(Object value) {
670	return map.containsValue(value);	×
671	}
672
673	@Override
674	public synchronized boolean containsKey(Object key) {
675	return map.containsKey(key);	×
676	}
677
678	@Override
679	public synchronized Object get(Object key) {
680	return map.get(key);	×
681	}
682
683	@Override
684	public synchronized Object put(Object key, Object value) {
685	return map.put(String.valueOf(key), value);	×
686	}
687
688	@Override
689	public synchronized Object remove(Object key) {
690	return map.remove(key);	×
691	}
692
693	@Override
694	public synchronized void putAll(Map<?, ?> t) {
695	map.putAll((Map<String, Object>) t);	×
696	}	×
697
698	@Override
699	public synchronized void clear() {
700	map.clear();	×
701	}	×
702
703	@Override
704	public Set<Object> keySet() {
705	return new LinkedHashSet<>(map.keySet());	×
706	}
707
708	@Override
709	public Set<Map.Entry<Object, Object>> entrySet() {
710	Set<Map.Entry<Object, Object>> set = new LinkedHashSet<>((Set) map.entrySet());	×
711	return new LinkedHashSet<>(set);	×
712	}
713
714	@Override
715	public Collection<Object> values() {
716	return map.values();	×
717	}
718
719	@Override
720	@SuppressWarnings("NoClone")
721	public synchronized Object clone() {
722	Map<String, Object> m = new LinkedHashMap<>(map);	×
723	return new MapToPropertiesAdapter(m);	×
724	}
725	}
726	}

jreleaser / jreleaser / #477

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous