javadoc

src/main/java/net/ranides/assira/collection/SetUtils.java

@@ -17,7 +17,7 @@ import net.ranides.assira.generic.ValueUtils;
  * @author ranides
  */
 public final class SetUtils {
-    
+
     private SetUtils() { }
 
     /**
@@ -49,7 +49,7 @@ public final class SetUtils {
     public static <K> Set<K> asTreeSet(K... values) {
         return new TreeSet<K>(Arrays.asList(values));
     }
-    
+
     /**
      * Tworzy nowy zbiór zawierający podane wartości {@code enum}.
      * @param <T>
@@ -59,8 +59,8 @@ public final class SetUtils {
     public static <T extends Enum<T>> EnumSet<T> asEnumSet(T... values) {
         return EnumSet.copyOf(Arrays.asList(values));
     }
-    
-    
+
+
     /**
      * Konwertuje podaną wartość na 1-elementowy zbiór. Uwaga! Zwróconego zbioru
      * nie da się modyfikować.
@@ -71,7 +71,7 @@ public final class SetUtils {
     public static <K> Set<K> wrap(K value) {
         return new SingleCollection<K>(value);
     }
-    
+
     /**
      * Wykonuje na elementach zbioru operację OR i zwraca wyliczony wynik.
      * @param values
@@ -82,7 +82,7 @@ public final class SetUtils {
         for(long value : values) { result |= value; }
         return result;
     }
-    
+
     /**
      * Wykonuje na elementach zbioru operację OR i zwraca wyliczony wynik.
      * @param values
@@ -93,7 +93,20 @@ public final class SetUtils {
         for(int value : values) { result |= value; }
         return result;
     }
-    
+
+    /**
+     * Tworzy na podstawie podanych wartości nowy adapter, który używa do dwu-stronnej
+     * transformacji wartości podanej funkcji. Zmiany wprowadzone w adapterze mają
+     * wpływ na kolekcję źródłową, i vice versa.
+     * <p>
+     * Adapter obsługuje wszystkie operacje odczytu, wstawiania oraz usuwania.
+     * </p>
+     * @param <T>
+     * @param <S>
+     * @param values
+     * @param function
+     * @return
+     */
     public static <T,S> Set<T> adapt(final Set<S> values, final BiFunction<T,S> function) {
         return new AbstractSet<T>() {
             @Override
@@ -122,7 +135,22 @@ public final class SetUtils {
             }
         };
     }
-    
+
+    /**
+     * Tworzy na podstawie podanych wartości nowy adapter, który używa do transformacji
+     * wartości podanej funkcji. Zmiany wprowadzone w kolekcji źródłowej są widoczne
+     * w adapterze.
+     * <p>
+     * Adapter jest kolekcją tylko do odczytu - nie obsługuje operacji wstawiania
+     * i usuwania (ponieważ do ich zaplementowania konieczne jest odwzorowanie
+     * dwukierunkowe).
+     * </p>
+     * @param <T>
+     * @param <S>
+     * @param values
+     * @param function
+     * @return
+     */
     public static <T,S> Set<T> adapt(final Set<S> values, final Function<T,S> function) {
         return new AbstractSet<T>() {
             @Override
@@ -140,10 +168,6 @@ public final class SetUtils {
             public Iterator<T> iterator() {
                 return CollectionUtils.adapt(values.iterator(), function);
             }
-            @Override
-            public void clear() {
-                values.clear();
-            }
         };
     }
 

src/main/java/net/ranides/assira/collection/SingleCollection.java

@@ -39,8 +39,9 @@ public class SingleCollection<T> implements List<T>, Set<T>, Serializable  {
 
     /**
      * Tworzy nową kolekcję zawierającą podany obiekt
+     * @param <ST>
      * @param value
-     * @return 
+     * @return
      */
     public static <ST> SingleCollection<ST> of(ST value) {
         return new SingleCollection<ST>(value);

src/main/java/net/ranides/assira/collection/list/NativeArrayList.java

@@ -17,16 +17,16 @@ import net.ranides.assira.reflection.UnsafeArrayAccess;
 /**
  * Lista odwzorowująca tablicę elementów typu prostego (int, float, etc)
  * dokonując jedynie po drodze koniecznego autoboxingu.
- * 
+ *
  * <p>
  * Utworzona lista posiada maksymalną pojemność wyliczoną na podstawie długości
- * prezentowanej tablicy (patrz: {@link #capacity() capacity}). Rozmiar listy nie ma 
+ * prezentowanej tablicy (patrz: {@link #capacity() capacity}). Rozmiar listy nie ma
  * bezpośredniego związku z długością tablicy i może mieć dowolną wartość z zakresu
  * [0;capacity]. Rozmiar listy może być modyfikowany: wszystkie operacje usuwania
  * i wstawiania są obsługiwane tak długo, jak długo nie zostanie przekroczony
- * dozwolony zakres. 
+ * dozwolony zakres.
  * </p>
- * 
+ *
  * <p>
  * Standardowe kolekcje nie mogą przechowywać typów prostych, co oznacza, że np
  * ArrayList nie przechowuje elementów typu int ale <b>obiekty</b> typu Integer.
@@ -36,16 +36,16 @@ import net.ranides.assira.reflection.UnsafeArrayAccess;
  * jest nowa alokacja pamięci i skopiowanie wszystkich danych do nowego formatu
  * (rzutowanie {@code Integer[] <-> int[]} jest niemożliwe).
  * </p><p>
- * JIT/HotSpot powinien sobie bez trudu poradzić z eliminacją operacji 
- * box'ujących - zwłaszcza biorąc pod uwagę wewnętrzną implementację 
+ * JIT/HotSpot powinien sobie bez trudu poradzić z eliminacją operacji
+ * box'ujących - zwłaszcza biorąc pod uwagę wewnętrzną implementację
  * {@code NativeArrayList}. Jest niemal pewne, że tradycyjnych pętli kopiujących
  * optymalizator nie może usunąć wcale.
  * </p>
- * 
- * @see ArrayUtils#wrap(Object) 
- * @see ArrayUtils#wrap(Class, Object) 
- * 
- * @param <T> 
+ *
+ * @see ArrayUtils#wrap(Object)
+ * @see ArrayUtils#wrap(Class, Object)
+ *
+ * @param <T>
  * @author ranides
  */
 @SuppressWarnings("unchecked")
@@ -57,8 +57,8 @@ public class NativeArrayList<T> extends AbstractList<T> implements RandomAccess
     private int size;
 
     /**
-     * Tworzy nową listę odwierciedlającą tablicę. 
-     * Modyfikacja listy zmienia zawartość tablicy, i vice versa. 
+     * Tworzy nową listę odwierciedlającą tablicę.
+     * Modyfikacja listy zmienia zawartość tablicy, i vice versa.
      * Rozmiar listy jest równy rozmiarowi podanej tablicy.
      * @param array
      * @see ArrayUtils#wrap(Object)
@@ -72,10 +72,10 @@ public class NativeArrayList<T> extends AbstractList<T> implements RandomAccess
     }
 
     /**
-     * Tworzy nową listę odwierciedlającą tablicę. 
-     * Modyfikacja listy zmienia zawartość tablicy, i vice versa. 
+     * Tworzy nową listę odwierciedlającą tablicę.
+     * Modyfikacja listy zmienia zawartość tablicy, i vice versa.
      * Początkowy rozmiar listy jest podawany jako argument.
-     * Do listy mogą być wstawiane nowe elementy tak długo, jak długo lista 
+     * Do listy mogą być wstawiane nowe elementy tak długo, jak długo lista
      * nie przekroczy maksymalnej pojemności tablicy.
      * @param array
      * @param size początkowy rozmiar zwracany przez listę
@@ -86,22 +86,22 @@ public class NativeArrayList<T> extends AbstractList<T> implements RandomAccess
     }
 
     /**
-     * Tworzy nową listę odwierciedlającą tablicę. 
-     * Modyfikacja listy zmienia zawartość tablicy, i vice versa. 
+     * Tworzy nową listę odwierciedlającą tablicę.
+     * Modyfikacja listy zmienia zawartość tablicy, i vice versa.
      * <p>
-     * Podana tablica jest "transparentnie" konwertowana na wskazany typ, a dopiero 
-     * wynik konwersji jest używany przez kolekcję. Przykładowo traktowanie 
-     * tablicy {@code long[]} jako tablicy {@code byte[]} umożliwia utworzenie 
+     * Podana tablica jest "transparentnie" konwertowana na wskazany typ, a dopiero
+     * wynik konwersji jest używany przez kolekcję. Przykładowo traktowanie
+     * tablicy {@code long[]} jako tablicy {@code byte[]} umożliwia utworzenie
      * listy typu {@code List<Byte>}. Konwersja jest wykonywana natywnie przez system hostujący (a nie przez VM!). Przekłada się to przede wszystkim na względnie większą wydajność kosztem nieprzenośności kodu ze względu na endianess.
      * </p>
      * <p>
      * Uwaga! Rzutowanie między typami o różnych rozmiarach powoduje, że lista ma
      * {@code capacity} różne niż {@code array.length}
      * </p>
-     * 
+     *
      * @param clazz
      * @param array
-     * 
+     *
      * @see ArrayUtils#wrap(Class, Object)
      */
     public NativeArrayList(Class<?> clazz, Object array) {
@@ -116,16 +116,16 @@ public class NativeArrayList<T> extends AbstractList<T> implements RandomAccess
     }
 
     /**
-     * Tworzy nową listę odwierciedlającą tablicę. 
-     * Modyfikacja listy zmienia zawartość tablicy, i vice versa. 
+     * Tworzy nową listę odwierciedlającą tablicę.
+     * Modyfikacja listy zmienia zawartość tablicy, i vice versa.
      * Początkowy rozmiar listy jest podawany jako argument.
-     * Do listy mogą być wstawiane nowe elementy tak długo, jak długo lista 
+     * Do listy mogą być wstawiane nowe elementy tak długo, jak długo lista
      * nie przekroczy maksymalnej pojemności tablicy.
-     * 
+     *
      * <p>
-     * Podana tablica jest "transparentnie" konwertowana na wskazany typ, a dopiero 
-     * wynik konwersji jest używany przez kolekcję. Przykładowo traktowanie 
-     * tablicy {@code long[]} jako tablicy {@code byte[]} umożliwia utworzenie 
+     * Podana tablica jest "transparentnie" konwertowana na wskazany typ, a dopiero
+     * wynik konwersji jest używany przez kolekcję. Przykładowo traktowanie
+     * tablicy {@code long[]} jako tablicy {@code byte[]} umożliwia utworzenie
      * listy typu {@code List<Byte>}. Konwersja jest wykonywana natywnie przez system hostujący (a nie przez VM!). Przekłada się to przede wszystkim na względnie większą wydajność kosztem nieprzenośności kodu ze względu na endianess.
      * </p>
      * <p>
@@ -140,10 +140,10 @@ public class NativeArrayList<T> extends AbstractList<T> implements RandomAccess
         this(clazz, array);
         this.size = size;
     }
-    
+
     /**
      * Zwraca maksymalny dopuszczalny rozmiar listy.
-     * @return 
+     * @return
      */
     public int capacity() {
         return capacity;
@@ -191,31 +191,41 @@ public class NativeArrayList<T> extends AbstractList<T> implements RandomAccess
         return prev;
     }
 
+    /**
+     * Zwraca typ elementów przechowywanych przez oryginalną tablicę.
+     * @return
+     */
     public Class<?> component() {
         return array.getClass().getComponentType();
     }
 
+    /**
+     * Zwraca oryginalną tablicę. Ponieważ jest to tablica typów prostych, to
+     * niemożliwe jest zwrócenie typu generycznego - wywołujący metodę samodzielnie
+     * musi dokonać odpowiedniego rzutowania.
+     * @return
+     */
     public Object delegator() {
         return array;
     }
-    
+
     private void checkCapacity(int index) {
         if(index >= capacity) {
             throw new IndexOutOfBoundsException(index + " out of maximal capacity " + capacity);
         }
     }
-    
+
     private void checkBounds(int index) {
         if(index >= size || index<0) {
             throw new IndexOutOfBoundsException(index +" out of bound " + size);
         }
     }
-    
+
     private void checkType(Class<?> clazz) {
         if (!clazz.isArray()) {
             throw new IllegalArgumentException(clazz + " is not an array");
         }
     }
-    
-    
+
+
 }

src/main/java/net/ranides/assira/collection/map/Column.java

@@ -13,43 +13,101 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.TreeMap;
 import java.util.WeakHashMap;
-import java.util.concurrent.ConcurrentHashMap;
+import net.ranides.assira.generic.Function;
 import net.ranides.assira.reflection.ClassInspector;
 import net.ranides.assira.reflection.Invoker;
 import net.ranides.assira.reflection.ObjectInspector;
 
 /**
- *
+ * Klasa, która pozwala na zapisanie nazwy i typu kolumny, która może być potem
+ * odczytywana i zapisywana do mapy. Pozwala na opisanie zawartości mapy w type-safe
+ * sposób, ambitniej iniż ma to zazwyczaj miejsce za pomocą stringów reprezentujących
+ * po prostu nazwy kluczy.
  * @author ranides
  * @param <K>
  * @param <V>
  */
-public class Column<K,V> {
+public class Column<K,V> implements Function<V, Map<K,? super V>> {
 
     private final K key;
     private final Class<V> type;
 
+    /**
+     * Tworzy nową kolumnę o podanej nazwie i typie.
+     * @param key
+     * @param type
+     */
     public Column(K key, Class<V> type) {
         this.key = key;
         this.type = type;
     }
 
+    /**
+     * Tworzy nową kolumnę o podanej nazwie i typie. Metoda statyczna pozwalająca
+     * na type-inference.
+     * @param <K>
+     * @param <V>
+     * @param key
+     * @param type
+     * @return
+     */
     public static <K,V> Column<K,V> make(K key, Class<V> type) {
         return new Column<K, V>(key, type);
     }
 
+    /**
+     * Pobiera z podanej mapy wartość zapisaną pod kluczem powiązanym z kolumną.
+     * @param map
+     * @return
+     */
     public V get(Map<K, ? super V> map) {
         return type.cast(map.get(key));
     }
 
+    /**
+     * Wstawia podaną wartość do mapy, przypisując do klucza powiązanego z kolumną.
+     * @param map
+     * @param value
+     */
     public void put(Map<K, ? super V> map, V value) {
         map.put(key, value);
     }
 
+    /**
+     * @see Column#get
+     * @param source
+     * @return
+     */
+    @Override
+    public V apply(Map<K, ? super V> source) {
+        return get(source);
+    }
+
+    /**
+     * Zwraca obiekt Entry powiązany z daną kolumną. Wszystkie zmiany wprowadzone
+     * w entry są widoczne w mapie źródłowej, i vice versa. Takie Entry pozwala
+     * na wielokrotne odczyty i zapisy do podanej kolumny bez konieczności wielokrotnego
+     * wyszukiwania klucza w mapie. Map zasadniczo pozytywny wpływ na wydajność
+     * w przypadku {@link TreeMap} - używanie Entry dla innych rodzajów map
+     * sprawdzają się (minimalnie) gorzej, niż ręczna praca z mapą.
+     * @param map
+     * @return
+     */
     public Entry<K,V> entry(Map<K, V> map) {
         return entry(map, key);
     }
 
+    /**
+     * Zwraca obiekt Entry powiązany z kluczem o podanej nazwie. Wszystkie zmiany wprowadzone
+     * w entry są widoczne w mapie źródłowej, i vice versa.
+     * <p>Metoda statyczna, pozwalająca na utworzenie Entry bez konieczności
+     * wcześniejszego definiowania kolumny.</p>
+     * @param <K>
+     * @param <V>
+     * @param map
+     * @param key
+     * @return
+     */
     public static <K,V> Entry<K,V> entry(Map<K, V> map, K key) {
         if(map instanceof TreeMap) {
             return (Map.Entry<K,V>)Invoker.invoke(map, EntryAccess.TREE, key);
@@ -64,24 +122,16 @@ public class Column<K,V> {
         if(map instanceof WeakHashMap) {
             return (Map.Entry<K,V>)Invoker.invoke(map, EntryAccess.WEAK, key);
         }
-        // it's slower than default "virtual" entry
-//        if(map instanceof ConcurrentHashMap) {
-//            return new CHEntry<K,V>(map, key);
-//        }
         return new DVEntry<K, V>(map, key);
     }
 
-    private static final class EntryAccess {
+
+    private static final class EntryAccess { // NOPMD - lazy init idiom
 
         private static final Method TREE;
         private static final Method HASH;
         private static final Method WEAK;
 
-        private static final Method CH_SEGMENT;
-        private static final Method CH_HASH;
-        private static final Method CH_GET;
-        private static final Method CH_PUT;
-
         private static final Class<?> CS_TREE_SUBMAP;
 
         static {
@@ -90,42 +140,6 @@ public class Column<K,V> {
 
             HASH = ClassInspector.findDeclaredMethod(HashMap.class, "getEntry");
             WEAK = ClassInspector.findDeclaredMethod(WeakHashMap.class, "getEntry");
-
-            CH_SEGMENT = ClassInspector.getDeclaredMethod(ConcurrentHashMap.class, "segmentFor", int.class);
-            CH_HASH = ClassInspector.getDeclaredMethod(ConcurrentHashMap.class, "hash", int.class);
-
-            Class<?> CS_SEGMENT = ClassInspector.forName("java.util.concurrent.ConcurrentHashMap$Segment");
-            CH_GET = ClassInspector.findDeclaredMethod(CS_SEGMENT, "get");
-            CH_PUT = ClassInspector.findDeclaredMethod(CS_SEGMENT, "put");
-        }
-
-    }
-
-    private static final class CHEntry<K,V> implements Map.Entry<K, V> {
-
-        private final K key;
-        private final int hash;
-        private final Object segment;
-
-        public CHEntry(Map<K,V> map, K key) {
-            this.key = key;
-            this.hash = (Integer)Invoker.invoke(null, EntryAccess.CH_HASH, key.hashCode());
-            this.segment = Invoker.invoke(map, EntryAccess.CH_SEGMENT, hash);
-        }
-
-        @Override
-        public K getKey() {
-            return key;
-        }
-
-        @Override
-        public V getValue() {
-            return (V)Invoker.invoke(segment, EntryAccess.CH_GET, key, hash);
-        }
-
-        @Override
-        public V setValue(V value) {
-            return (V)Invoker.invoke(segment, EntryAccess.CH_PUT, key, hash, value, false);
         }
 
     }

src/main/java/net/ranides/assira/collection/map/VirtualMap.java

@@ -16,13 +16,20 @@ import net.ranides.assira.generic.BiFunction;
 import net.ranides.assira.generic.Function;
 
 /**
- *
+ * Abstrakcyjna klasa - adapter, po której dziedziczą implementacje prezentujące
+ * obiekty funkcyjne jako interfejs map. Zobacz opis metody {@link VirtualMap#produce}.
  * @author ranides
+ * @param <K>
+ * @param <V>
  */
 public abstract class VirtualMap<K, V> implements Map<K, V> {
 
     private final String message;
 
+    /**
+     *
+     * @param message
+     */
     protected VirtualMap(String message) {
         this.message = message;
     }

src/main/java/net/ranides/assira/config/Branch.java

@@ -9,9 +9,12 @@ package net.ranides.assira.config;
 import java.util.List;
 import java.util.Map;
 import net.ranides.assira.generic.TypeToken;
+import net.ranides.assira.text.LexicalCast;
 
 /**
- *
+ * Interfejs reprezentujący zbiór wartości konfiguracyjnych, zorganizowanych w
+ * strukturę drzewiastą. Gałąź może zawierać nie tylko konkretne wartości, ale
+ * również kolejne, zagnieżdżone gałęzie.
  * @author ranides
  */
 public interface Branch {
@@ -41,18 +44,68 @@ public interface Branch {
      */
     Map<String,Object> asFlatMap();
 
+    /**
+     * Zwraca gałąź zagnieżdżoną w bieżącym obiekcie.
+     * @param path
+     * @return
+     */
     Branch branch(String path);
 
+    /**
+     * Zwraca listę ścieżek, reprezentujących gałęzie zawarte w bieżącym obiekcie.
+     * @param path
+     * @return
+     */
     List<Branch> branchList(String path);
 
 /* ************************************************************************** */
 
-    <T> T get(TypeToken<T> type, String path, T ddefault);
+    /**
+     * Pobiera wartość zapisaną we wskazanej lokalizacji dokonując w razie potrzeby
+     * rzutowania za pomocą {@link LexicalCast#cast}. Zwraca wartość domyślną, jeśli
+     * wartość nie istnieje.
+     * @param <T>
+     * @param type
+     * @param path
+     * @param ddefault
+     * @return
+     */
+<T> T get(TypeToken<T> type, String path, T ddefault);
 
+    /**
+     * Pobiera wartość zapisaną we wskazanej lokalizacji dokonując w razie potrzeby
+     * rzutowania za pomocą {@link LexicalCast#cast}. Rzuca wyjątkiem, jeśli wartość
+     * nie istnieje.
+     * @param <T>
+     * @param type
+     * @param path
+     * @return
+     * @throws ConfigException
+     */
     <T> T get(TypeToken<T> type, String path) throws ConfigException;
 
+    /**
+     * Pobiera wartość zapisaną we wskazanej lokalizacji dokonując w razie potrzeby
+     * rzutowania za pomocą {@link LexicalCast#cast}. Zwraca wartość domyślną, jeśli
+     * wartość nie istnieje.
+     * @param <T>
+     * @param type
+     * @param path
+     * @param ddefault
+     * @return
+     */
     <T> T get(Class<T> type, String path, T ddefault);
 
+    /**
+     * Pobiera wartość zapisaną we wskazanej lokalizacji dokonując w razie potrzeby
+     * rzutowania za pomocą {@link LexicalCast#cast}. Rzuca wyjątkiem, jeśli wartość
+     * nie istnieje.
+     * @param <T>
+     * @param type
+     * @param path
+     * @return
+     * @throws ConfigException
+     */
     <T> T get(Class<T> type, String path) throws ConfigException;
 
     /**
@@ -72,8 +125,28 @@ public interface Branch {
      */
     Object get(String path) throws ConfigException;
 
+    /**
+     * Pobiera listę wartości zapisanych we wskazanej lokalizacji. Może zwrócić
+     * pustą listę, jeśli nie znaleziono niczego we wskazanej lokalizacji. W razie
+     * potrzeby dokonuje odpowiedniego rzutowania elementów listy za pomocą
+     * {@link LexicalCast#cast}.
+     * @param <T>
+     * @param type
+     * @param path
+     * @return
+     */
     <T> List<T> getList(TypeToken<T> type, String path);
 
+    /**
+     * Pobiera listę wartości zapisanych we wskazanej lokalizacji. Może zwrócić
+     * pustą listę, jeśli nie znaleziono niczego we wskazanej lokalizacji. W razie
+     * potrzeby dokonuje odpowiedniego rzutowania elementów listy za pomocą
+     * {@link LexicalCast#cast}.
+     * @param <T>
+     * @param type
+     * @param path
+     * @return
+     */
     <T> List<T> getList(Class<T> type, String path);
 
     /**
@@ -84,8 +157,26 @@ public interface Branch {
      */
     List<?> getList(String path) throws ConfigException;
 
+    /**
+     * Zmienia wartość pod wskazaną lokalizacją. W razie potrzeby dokonuje rzutowania
+     * {@code value} na typ {@type} za pomocą {@link LexicalCast#cast}.
+     * @param <T>
+     * @param type
+     * @param path
+     * @param value
+     * @throws ConfigException
+     */
     <T> void put(TypeToken<T> type, String path, Object value) throws ConfigException;
 
+    /**
+     * Zmienia wartość pod wskazaną lokalizacją. W razie potrzeby dokonuje rzutowania
+     * {@code value} na typ {@type} za pomocą {@link LexicalCast#cast}.
+     * @param <T>
+     * @param type
+     * @param path
+     * @param value
+     * @throws ConfigException
+     */
     <T> void put(Class<T> type, String path, Object value) throws ConfigException;
 
     /**
@@ -96,8 +187,28 @@ public interface Branch {
      */
     void put(String path, Object value) throws ConfigException;
 
+    /**
+     * Wstawia wiele wartości pod wskazaną lokalizację (usuwając poprzednie).
+     * W razie potrzeby dokonuje rzutowania elementów listy na typ {@type} za pomocą
+     * {@link LexicalCast#cast}.
+     * @param <T>
+     * @param type
+     * @param path
+     * @param value
+     * @throws ConfigException
+     */
     <T> void putList(TypeToken<T> type, String path, List<?> value) throws ConfigException;
 
+    /**
+     * Umieszcza listę wartości pod wskazaną lokalizacją.
+     * W razie potrzeby dokonuje rzutowania elementów listy na typ {@type} za pomocą
+     * {@link LexicalCast#cast}.
+     * @param <T>
+     * @param type
+     * @param path
+     * @param value
+     * @throws ConfigException
+     */
     <T> void putList(Class<T> type, String path, List<?> value) throws ConfigException;
 
     /**

src/main/java/net/ranides/assira/enums/EnumUtils.java

@@ -20,9 +20,7 @@ import net.ranides.assira.trace.AdvLogger;
 import net.ranides.assira.trace.LoggerUtils;
 
 /**
- * Klasa, która utworzona na rzecz konkretnego typu {@code enum} umożliwa dokonanie
- * pewnych sprawdzeń za pomocą inspekcji
- * @param <E>
+ * 
  * @author ranides
  */
 public final class EnumUtils {