From a3350f4dac32a3207d175348e45828d96e8fda38 Mon Sep 17 00:00:00 2001 From: Aleksey Kalenchukov Date: Fri, 24 Jun 2022 19:21:33 +0300 Subject: [PATCH] =?UTF-8?q?=D0=98=D0=BD=D0=B8=D1=86=D0=B8=D0=B0=D0=BB?= =?UTF-8?q?=D0=B8=D0=B7=D0=B0=D1=86=D0=B8=D1=8F=20=D0=BF=D1=80=D0=BE=D0=B5?= =?UTF-8?q?=D0=BA=D1=82=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 4 + LICENSE | 21 + README.MD | 148 +++++ TODO.MD | 8 + pom.xml | 61 ++ .../lemna/injection/Injectable.java | 44 ++ .../lemna/injection/Injection.java | 238 +++++++ .../injection/annotations/Converter.java | 26 + .../injection/annotations/package-info.java | 7 + .../converters/ConverterRepository.java | 151 +++++ .../arrays/ArrayOfBooleanConverter.java | 34 + .../arrays/ArrayOfByteConverter.java | 34 + .../arrays/ArrayOfCharacterConverter.java | 34 + .../arrays/ArrayOfDoubleConverter.java | 34 + .../arrays/ArrayOfFloatConverter.java | 34 + .../arrays/ArrayOfIntegerConverter.java | 34 + .../arrays/ArrayOfLongConverter.java | 34 + .../arrays/ArrayOfShortConverter.java | 34 + .../arrays/ArrayOfStringConverter.java | 34 + .../converters/arrays/package-info.java | 7 + .../CollectionBooleanConverter.java | 39 ++ .../collections/CollectionByteConverter.java | 39 ++ .../CollectionCharacterConverter.java | 39 ++ .../CollectionDoubleConverter.java | 39 ++ .../collections/CollectionFloatConverter.java | 39 ++ .../CollectionIntegerConverter.java | 41 ++ .../collections/CollectionLongConverter.java | 39 ++ .../collections/CollectionShortConverter.java | 39 ++ .../CollectionStringConverter.java | 41 ++ .../converters/collections/package-info.java | 7 + .../lists/ListBooleanConverter.java | 40 ++ .../converters/lists/ListByteConverter.java | 40 ++ .../lists/ListCharacterConverter.java | 40 ++ .../converters/lists/ListDoubleConverter.java | 40 ++ .../converters/lists/ListFloatConverter.java | 40 ++ .../lists/ListIntegerConverter.java | 40 ++ .../converters/lists/ListLongConverter.java | 40 ++ .../converters/lists/ListShortConverter.java | 40 ++ .../converters/lists/ListStringConverter.java | 40 ++ .../converters/lists/package-info.java | 7 + .../injection/converters/package-info.java | 7 + .../converters/sets/SetBooleanConverter.java | 40 ++ .../converters/sets/SetByteConverter.java | 40 ++ .../sets/SetCharacterConverter.java | 40 ++ .../converters/sets/SetDoubleConverter.java | 40 ++ .../converters/sets/SetFloatConverter.java | 40 ++ .../converters/sets/SetIntegerConverter.java | 39 ++ .../converters/sets/SetLongConverter.java | 40 ++ .../converters/sets/SetShortConverter.java | 40 ++ .../converters/sets/SetStringConverter.java | 40 ++ .../converters/sets/package-info.java | 7 + .../converters/singles/BooleanConverter.java | 31 + .../converters/singles/ByteConverter.java | 33 + .../singles/CharacterConverter.java | 33 + .../converters/singles/DoubleConverter.java | 33 + .../converters/singles/FloatConverter.java | 33 + .../converters/singles/IntegerConverter.java | 33 + .../converters/singles/LongConverter.java | 33 + .../converters/singles/ShortConverter.java | 33 + .../converters/singles/StringConverter.java | 26 + .../converters/singles/package-info.java | 7 + .../exceptions/IllegalValueException.java | 27 + .../exceptions/InvalidConverterException.java | 27 + .../exceptions/UnableConverterException.java | 32 + .../exceptions/UnknownConverterException.java | 27 + .../injection/exceptions/package-info.java | 7 + .../injection/interfaces/Converting.java | 29 + .../injection/interfaces/package-info.java | 1 + .../lemna/injection/package-info.java | 7 + src/main/java/module-info.java | 16 + .../localizations/exceptions_ru_RU.properties | 4 + .../localizations/logs_ru_RU.properties | 10 + src/main/resources/log4j.properties | 17 + .../lemna/injection/InjectionTest.java | 620 ++++++++++++++++++ .../supports/ArrayOfGenderConverter.java | 33 + .../supports/CollectionOfGenderConverter.java | 37 ++ .../lemna/injection/supports/Gender.java | 13 + .../supports/ListOfGenderConverter.java | 39 ++ .../supports/SetOfGenderConverter.java | 39 ++ .../supports/SingleGenderConverter.java | 34 + 80 files changed, 3437 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.MD create mode 100644 TODO.MD create mode 100644 pom.xml create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/Injectable.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/Injection.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/annotations/Converter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/annotations/package-info.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/ConverterRepository.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfBooleanConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfByteConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfCharacterConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfDoubleConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfFloatConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfIntegerConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfLongConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfShortConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfStringConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/package-info.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionBooleanConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionByteConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionCharacterConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionDoubleConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionFloatConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionIntegerConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionLongConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionShortConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionStringConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/collections/package-info.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListBooleanConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListByteConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListCharacterConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListDoubleConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListFloatConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListIntegerConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListLongConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListShortConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListStringConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/lists/package-info.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/package-info.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetBooleanConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetByteConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetCharacterConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetDoubleConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetFloatConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetIntegerConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetLongConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetShortConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetStringConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/sets/package-info.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/singles/BooleanConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/singles/ByteConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/singles/CharacterConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/singles/DoubleConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/singles/FloatConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/singles/IntegerConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/singles/LongConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/singles/ShortConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/singles/StringConverter.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/converters/singles/package-info.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/exceptions/IllegalValueException.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/exceptions/InvalidConverterException.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/exceptions/UnableConverterException.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/exceptions/UnknownConverterException.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/exceptions/package-info.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/interfaces/Converting.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/interfaces/package-info.java create mode 100644 src/main/java/dev/kalenchukov/lemna/injection/package-info.java create mode 100644 src/main/java/module-info.java create mode 100644 src/main/resources/localizations/exceptions_ru_RU.properties create mode 100644 src/main/resources/localizations/logs_ru_RU.properties create mode 100644 src/main/resources/log4j.properties create mode 100644 src/test/java/dev/kalenchukov/lemna/injection/InjectionTest.java create mode 100644 src/test/java/dev/kalenchukov/lemna/injection/supports/ArrayOfGenderConverter.java create mode 100644 src/test/java/dev/kalenchukov/lemna/injection/supports/CollectionOfGenderConverter.java create mode 100644 src/test/java/dev/kalenchukov/lemna/injection/supports/Gender.java create mode 100644 src/test/java/dev/kalenchukov/lemna/injection/supports/ListOfGenderConverter.java create mode 100644 src/test/java/dev/kalenchukov/lemna/injection/supports/SetOfGenderConverter.java create mode 100644 src/test/java/dev/kalenchukov/lemna/injection/supports/SingleGenderConverter.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..380c695 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +/.idea +/out +/*.iml +/target diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e17381e --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Aleksey Kalenchukov + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.MD b/README.MD new file mode 100644 index 0000000..e6190a5 --- /dev/null +++ b/README.MD @@ -0,0 +1,148 @@ +# Lemna Injection +Внедрение значений в поля классов. + +### Поддерживаемые типы данных полей + +```java +Integer, Short, Float, Double, Long, String, Character, Boolean, Byte +``` +```java +Integer[], Short[], Float[], Double[], Long[], String[], Character[], +Boolean[], Byte[] +``` +```java +Collection, Collection, Collection, Collection, +Collection, Collection, Collection, Collection, +Collection +``` +```java +List, List, List, List, List, List, +List, List, List +``` +```java +Set, Set, Set, Set, Set, Set, +Set, Set, Set +``` + +Для других типов данных необходимо создавать свои конвертеры. + +Примитивные типы данных не поддерживаются. + +### Внедрение значений в поля класса +Класс, в поля которого необходимо внедрить значения: +```java +public class Experimental +{ + private String varOne; + + private Integer varTwo; + + public String getVarOne() + { + return this.varOne; + } + + public Integer getVarTwo() + { + return this.varTwo; + } +} +``` + +Данные которые необходимо внедрить в поля. +```java +Map data = new HashMap<>(); +data.put("varOne", new String[]{"Значение первого поля"}); +data.put("varTwo", new String[]{"13"}); +``` + +Вызов инжектора: +```java +Experimental experimental = new Experimental(); + +Injectable injection = new Injection(experimental); +injection.inject(data); + +experimental.getVarOne(); +/* +Результат выполнения: Значение первого поля +*/ + +experimental.getVarTwo(); +/* +Результат выполнения: 13 +*/ +``` + +### Создание конвертера типа данных +Свой тип данных. +```java +public enum Gender +{ + M, + F; +} +``` + +Для создания конвертера типа данных необходимо создать класс реализующий интерфейс "Converting". + +```java +import Converting; + +public final class GenderConverter implements Converting +{ + @Override + public @Nullable Gender convert(@Nullable String @Nullable [] value) throws UnableConverterException + { + if (value == null || value[0] == null) + { + return null; + } + + try + { + return Gender.valueOf(value[0]); + } + catch (IllegalArgumentException exception) + { + throw new UnableConverterException(); + } + } +} +``` + +Класс для поля которого необходим конвертер: + +```java +import Converter; + +public class Experimental +{ + @Converter(converter = GenderConverter.class) + private Gender gender; + + public Gender getGender() + { + return this.gender; + } +} +``` + +Данные для внедрения: +```java +Map data = new HashMap<>(); +data.put("gender", new String[]{"F"}); +``` + +Вызов инжектора: +```java +Experimental experimental = new Experimental(); + +Injectable injection = new Injection(experimental); +injection.inject(data); + +experimental.getGender(); +/* +Результат выполнения: F +*/ +``` \ No newline at end of file diff --git a/TODO.MD b/TODO.MD new file mode 100644 index 0000000..5b2349c --- /dev/null +++ b/TODO.MD @@ -0,0 +1,8 @@ +[+] - нужно сделать +[?] - возможно нужно сделать +[>] - перенос в новую версию +[x] - не делать + +# CORE +* [>] Сделать настройку чтобы не присваивал значение тем полям, которые не null +* diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..ec36c8e --- /dev/null +++ b/pom.xml @@ -0,0 +1,61 @@ + + + + + 4.0.0 + + dev.kalenchukov + lemna-injection + 1.0.0 + + Lemna Injection + Внедрение значений в поля классов + https://github.com/kalenchukov/LemnaInjection + + + + MIT License + https://opensource.org/licenses/MIT + + + + + + kalenchukov + Алексей Каленчуков + aleksey.kalenchukov@yandex.ru + https://github.com/kalenchukov + + + + + 18 + 18 + UTF-8 + + + + + org.jetbrains + annotations + 23.0.0 + + + log4j + log4j + 1.2.17 + + + junit + junit + 4.13.2 + + + + \ No newline at end of file diff --git a/src/main/java/dev/kalenchukov/lemna/injection/Injectable.java b/src/main/java/dev/kalenchukov/lemna/injection/Injectable.java new file mode 100644 index 0000000..935686a --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/Injectable.java @@ -0,0 +1,44 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection; + +import dev.kalenchukov.lemna.injection.exceptions.InvalidConverterException; +import dev.kalenchukov.lemna.injection.exceptions.IllegalValueException; +import dev.kalenchukov.lemna.injection.exceptions.UnknownConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Locale; +import java.util.Map; + +/** + * Интерфейс для реализации внедряющего в поля класса данные. + */ +public interface Injectable +{ + /** + * Устанавливает локализацию. + * + * @param locale Локализация. + */ + void setLocale(@NotNull Locale locale); + + /** + * Внедряет данные в поля класса. + * + * @param data Данные которые необходимо внедрить в поля класса. + *
    + *
  • key - поле класса.
    • + *
  • value - массив значений.
    • + *
+ * @throws IllegalValueException Если передано некорректное значение для внедрения в данное поле класса. + * @throws UnknownConverterException Если для типа поля не реализован персональный конвертер. + * @throws InvalidConverterException Если конвертер некорректный. + */ + void inject(@NotNull Map<@NotNull String, @Nullable String @Nullable []> data) + throws IllegalValueException, UnknownConverterException, InvalidConverterException; +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/Injection.java b/src/main/java/dev/kalenchukov/lemna/injection/Injection.java new file mode 100644 index 0000000..a1f0044 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/Injection.java @@ -0,0 +1,238 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection; + +import dev.kalenchukov.lemna.injection.annotations.Converter; +import dev.kalenchukov.lemna.injection.converters.ConverterRepository; +import dev.kalenchukov.lemna.injection.exceptions.IllegalValueException; +import dev.kalenchukov.lemna.injection.exceptions.InvalidConverterException; +import dev.kalenchukov.lemna.injection.exceptions.UnknownConverterException; +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import org.apache.log4j.Logger; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.*; + +/** + * Внедряет данные в поля класса. + */ +public class Injection implements Injectable +{ + /** + * Локализация. + */ + @NotNull + private Locale locale = new Locale("ru", "RU"); + + /** + * Объект класса в который необходимо внедрять данные. + */ + @NotNull + private final Object object; + + /** + * Репозиторий конвертеров типов данных. + */ + @NotNull + private final ConverterRepository converterRepository = new ConverterRepository(); + + /** + * Логгер для данного класса. + */ + @NotNull + private static final Logger LOG = Logger.getLogger(Injection.class); + + /** + * Локализованные тексты логирования. + */ + @NotNull + private ResourceBundle localeLogs = ResourceBundle.getBundle("localizations/logs", locale); + + /** + * Локализованные тексты исключений. + */ + @NotNull + private ResourceBundle localeExceptions = ResourceBundle.getBundle("localizations/exceptions", locale); + + /** + * Конструктор для {@code Injection}. + * + * @param object Объект класса в который необходимо внедрить данные. + */ + public Injection(@NotNull final Object object) + { + Objects.requireNonNull(object); + + this.object = object; + } + + /** + * @see Injectable#setLocale(Locale) + */ + public void setLocale(@NotNull Locale locale) + { + Objects.requireNonNull(locale); + + if (!this.locale.equals(locale)) + { + this.locale = locale; + + localeLogs = ResourceBundle.getBundle("localizations/logs", this.locale); + localeExceptions = ResourceBundle.getBundle("localizations/exceptions", this.locale); + } + } + + /** + * @see Injectable#inject(Map) + */ + @Override + public void inject(@NotNull final Map<@NotNull String, @Nullable String @Nullable []> data) + throws IllegalValueException, UnknownConverterException, InvalidConverterException + { + Objects.requireNonNull(data); + + LOG.debug(String.format( + localeLogs.getString("60001"), + this.object.getClass().getName() + )); + + if (data.size() > 0) + { + this.findPersonalConverters(); + + for (Field field : this.object.getClass().getDeclaredFields()) + { + String[] value = data.get(field.getName()); + + if (value == null) + { + LOG.debug(String.format( + localeLogs.getString("60003"), + field.getName() + )); + + continue; + } + + field.setAccessible(true); + + this.injectValueField(field, value); + + field.setAccessible(false); + } + } + + LOG.debug(String.format( + localeLogs.getString("60002"), + this.object.getClass().getName() + )); + } + + /** + * Внедряет значение в поле класса. + * + * @param field Поле класса в которое необходимо внедрить значение. + * @param value Коллекция значений которые необходимо внедрить в поле класса. + * + * @throws IllegalValueException Если передано некорректное значение для внедрения в данное поле класса. + * @throws UnknownConverterException Если для типа поля не реализован персональный конвертер. + * @throws InvalidConverterException Если конвертер некорректный. + */ + private void injectValueField(@NotNull final Field field, @Nullable final String @Nullable [] value) + throws IllegalValueException, UnknownConverterException, InvalidConverterException + { + Objects.requireNonNull(field); + Objects.requireNonNull(value); + + boolean has = this.converterRepository.getConverters().containsKey( + field.getGenericType().getTypeName() + ); + + if (!has) { + throw new UnknownConverterException(String.format( + localeExceptions.getString("70002"), + field.getGenericType().getTypeName(), + this.object.getClass().getName() + )); + } + + Class> converter = this.converterRepository.getConverters().get( + field.getGenericType().getTypeName() + ); + + try + { + Method method = converter.getDeclaredMethod("convert", String[].class); + +// System.out.println(String[].class.getTypeName()); +// System.out.println(value.getClass().getTypeName()); + + field.set( + this.object, + method.invoke( + converter.getConstructor().newInstance(), + (Object) value + ) + ); + } + catch (InvocationTargetException exception) + { + throw new IllegalValueException(String.format( + localeExceptions.getString("70001"), + field.getName(), + this.object.getClass().getName() + )); + } + catch (IllegalArgumentException | NoSuchMethodException | + IllegalAccessException | InstantiationException exception) + { + throw new InvalidConverterException(String.format( + localeExceptions.getString("70003"), + converter.getName(), + this.object.getClass().getName() + )); + } + + LOG.debug(String.format( + localeLogs.getString("60004"), + field.getName() + )); + } + + /** + * Ищет персональные конвертеры для типов данных. + */ + private void findPersonalConverters() + { + for (Field field : this.object.getClass().getDeclaredFields()) + { + Converter[] annotationsConverter = field.getAnnotationsByType(Converter.class); + + if (annotationsConverter.length == 0) { + return; + } + + for (Converter annotationConverter : annotationsConverter) + { + this.converterRepository.addConverter( + field.getGenericType().getTypeName(), + annotationConverter.converter() + ); + + LOG.debug(String.format( + localeLogs.getString("60005"), + annotationConverter.converter().getTypeName(), + field.getGenericType().getTypeName() + )); + } + } + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/annotations/Converter.java b/src/main/java/dev/kalenchukov/lemna/injection/annotations/Converter.java new file mode 100644 index 0000000..6b8fa83 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/annotations/Converter.java @@ -0,0 +1,26 @@ +package dev.kalenchukov.lemna.injection.annotations; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import org.jetbrains.annotations.NotNull; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + + +/** + * Задаёт персональный конвертер типа данных для поля класса. + */ +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.FIELD}) +public @interface Converter +{ + /** + * Задаёт класс конвертера типа данных. + * + * @return Класс конвертера типа данных. + */ + @NotNull + Class> converter(); +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/annotations/package-info.java b/src/main/java/dev/kalenchukov/lemna/injection/annotations/package-info.java new file mode 100644 index 0000000..bdcfc41 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/annotations/package-info.java @@ -0,0 +1,7 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.annotations; \ No newline at end of file diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/ConverterRepository.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/ConverterRepository.java new file mode 100644 index 0000000..0ac4fd4 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/ConverterRepository.java @@ -0,0 +1,151 @@ +/* + * Copyright © 2021 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.converters; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.*; +import dev.kalenchukov.lemna.injection.converters.collections.*; +import dev.kalenchukov.lemna.injection.converters.lists.*; +import dev.kalenchukov.lemna.injection.converters.sets.*; +import dev.kalenchukov.lemna.injection.converters.singles.*; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.UnmodifiableView; + +import java.util.*; + +/** + * Класс репозиторий всех конвертеров типа данных. + */ +public final class ConverterRepository +{ + /** + * Коллекция конвертеров типа данных. + */ + @NotNull + private final Map<@NotNull String, @NotNull Class>> converters = new HashMap<>(); + + /** + * Конструктор для {@code ConverterRepository}. + */ + public ConverterRepository() + { + this.addConverters(); + this.addConvertersArray(); + this.addConvertersCollection(); + this.addConvertersList(); + this.addConvertersSet(); + } + + /** + * Возвращает коллекцию конвертеров типа данных. + * + * @return Коллекцию конвертеров типа данных. + */ + @UnmodifiableView + @NotNull + public Map<@NotNull String, @NotNull Class>> getConverters() + { + return Collections.unmodifiableMap(this.converters); + } + + /** + * Добавляет конвертер типа данных. + * + * @param forType Тип данных для которого используется конвертер. + * @param converter Класс конвертера типа данных. + */ + public void addConverter(@NotNull final String forType, + @NotNull final Class> converter) + { + Objects.requireNonNull(forType); + Objects.requireNonNull(converter); + + if (!this.converters.containsKey(forType)) { + this.converters.put(forType, converter); + } + } + + /** + * Добавляет конвертеры типов данных. + */ + private void addConverters() + { + this.addConverter(Short.class.getTypeName(), ShortConverter.class); + this.addConverter(Integer.class.getTypeName(), IntegerConverter.class); + this.addConverter(Long.class.getTypeName(), LongConverter.class); + this.addConverter(String.class.getTypeName(), StringConverter.class); + this.addConverter(Boolean.class.getTypeName(), BooleanConverter.class); + this.addConverter(Float.class.getTypeName(), FloatConverter.class); + this.addConverter(Double.class.getTypeName(), DoubleConverter.class); + this.addConverter(Character.class.getTypeName(), CharacterConverter.class); + this.addConverter(Byte.class.getTypeName(), ByteConverter.class); + } + + /** + * Добавляет конвертеры типов данных в {@code Array}. + */ + private void addConvertersArray() + { + this.addConverter(Short[].class.getTypeName(), ArrayOfShortConverter.class); + this.addConverter(Integer[].class.getTypeName(), ArrayOfIntegerConverter.class); + this.addConverter(Long[].class.getTypeName(), ArrayOfLongConverter.class); + this.addConverter(String[].class.getTypeName(), ArrayOfStringConverter.class); + this.addConverter(Boolean[].class.getTypeName(), ArrayOfBooleanConverter.class); + this.addConverter(Float[].class.getTypeName(), ArrayOfFloatConverter.class); + this.addConverter(Double[].class.getTypeName(), ArrayOfDoubleConverter.class); + this.addConverter(Character[].class.getTypeName(), ArrayOfCharacterConverter.class); + this.addConverter(Byte[].class.getTypeName(), ArrayOfByteConverter.class); + } + + /** + * Добавляет конвертеры типов данных в {@code Collection}. + */ + private void addConvertersCollection() + { + this.addConverter(Collection.class.getTypeName() + "<" + Short.class.getTypeName() + ">", CollectionShortConverter.class); + this.addConverter(Collection.class.getTypeName() + "<" + Integer.class.getTypeName() + ">", CollectionIntegerConverter.class); + this.addConverter(Collection.class.getTypeName() + "<" + Long.class.getTypeName() + ">", CollectionLongConverter.class); + this.addConverter(Collection.class.getTypeName() + "<" + String.class.getTypeName() + ">", CollectionStringConverter.class); + this.addConverter(Collection.class.getTypeName() + "<" + Boolean.class.getTypeName() + ">", CollectionBooleanConverter.class); + this.addConverter(Collection.class.getTypeName() + "<" + Float.class.getTypeName() + ">", CollectionFloatConverter.class); + this.addConverter(Collection.class.getTypeName() + "<" + Double.class.getTypeName() + ">", CollectionDoubleConverter.class); + this.addConverter(Collection.class.getTypeName() + "<" + Character.class.getTypeName() + ">", CollectionCharacterConverter.class); + this.addConverter(Collection.class.getTypeName() + "<" + Byte.class.getTypeName() + ">", CollectionByteConverter.class); + } + + /** + * Добавляет конвертеры типов данных в {@code List}. + */ + private void addConvertersList() + { + this.addConverter(List.class.getTypeName() + "<" + Short.class.getTypeName() + ">", ListShortConverter.class); + this.addConverter(List.class.getTypeName() + "<" + Integer.class.getTypeName() + ">", ListIntegerConverter.class); + this.addConverter(List.class.getTypeName() + "<" + Long.class.getTypeName() + ">", ListLongConverter.class); + this.addConverter(List.class.getTypeName() + "<" + String.class.getTypeName() + ">", ListStringConverter.class); + this.addConverter(List.class.getTypeName() + "<" + Boolean.class.getTypeName() + ">", ListBooleanConverter.class); + this.addConverter(List.class.getTypeName() + "<" + Float.class.getTypeName() + ">", ListFloatConverter.class); + this.addConverter(List.class.getTypeName() + "<" + Double.class.getTypeName() + ">", ListDoubleConverter.class); + this.addConverter(List.class.getTypeName() + "<" + Character.class.getTypeName() + ">", ListCharacterConverter.class); + this.addConverter(List.class.getTypeName() + "<" + Byte.class.getTypeName() + ">", ListByteConverter.class); + } + + /** + * Добавляет конвертеры типов данных в {@code Set}. + */ + private void addConvertersSet() + { + this.addConverter(Set.class.getTypeName() + "<" + Short.class.getTypeName() + ">", SetShortConverter.class); + this.addConverter(Set.class.getTypeName() + "<" + Integer.class.getTypeName() + ">", SetIntegerConverter.class); + this.addConverter(Set.class.getTypeName() + "<" + Long.class.getTypeName() + ">", SetLongConverter.class); + this.addConverter(Set.class.getTypeName() + "<" + String.class.getTypeName() + ">", SetStringConverter.class); + this.addConverter(Set.class.getTypeName() + "<" + Boolean.class.getTypeName() + ">", SetBooleanConverter.class); + this.addConverter(Set.class.getTypeName() + "<" + Float.class.getTypeName() + ">", SetFloatConverter.class); + this.addConverter(Set.class.getTypeName() + "<" + Double.class.getTypeName() + ">", SetDoubleConverter.class); + this.addConverter(Set.class.getTypeName() + "<" + Character.class.getTypeName() + ">", SetCharacterConverter.class); + this.addConverter(Set.class.getTypeName() + "<" + Byte.class.getTypeName() + ">", SetByteConverter.class); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfBooleanConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfBooleanConverter.java new file mode 100644 index 0000000..d466845 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfBooleanConverter.java @@ -0,0 +1,34 @@ +package dev.kalenchukov.lemna.injection.converters.arrays; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.singles.BooleanConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Boolean[]}. + */ +public final class ArrayOfBooleanConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Boolean @Nullable [] convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null) { + return null; + } + + Boolean[] convertValue = new Boolean[value.length]; + + for (int elm = 0; elm < value.length; elm++) + { + convertValue[elm] = new BooleanConverter().convert(new String[]{value[elm]}); + } + + return convertValue; + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfByteConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfByteConverter.java new file mode 100644 index 0000000..57f6a37 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfByteConverter.java @@ -0,0 +1,34 @@ +package dev.kalenchukov.lemna.injection.converters.arrays; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.singles.ByteConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Byte[]}. + */ +public final class ArrayOfByteConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Byte @Nullable [] convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null) { + return null; + } + + Byte[] convertValue = new Byte[value.length]; + + for (int elm = 0; elm < value.length; elm++) + { + convertValue[elm] = new ByteConverter().convert(new String[]{value[elm]}); + } + + return convertValue; + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfCharacterConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfCharacterConverter.java new file mode 100644 index 0000000..fcc2854 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfCharacterConverter.java @@ -0,0 +1,34 @@ +package dev.kalenchukov.lemna.injection.converters.arrays; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.singles.CharacterConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Character[]}. + */ +public final class ArrayOfCharacterConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Character @Nullable [] convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null) { + return null; + } + + Character[] convertValue = new Character[value.length]; + + for (int elm = 0; elm < value.length; elm++) + { + convertValue[elm] = new CharacterConverter().convert(new String[]{value[elm]}); + } + + return convertValue; + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfDoubleConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfDoubleConverter.java new file mode 100644 index 0000000..b4eb833 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfDoubleConverter.java @@ -0,0 +1,34 @@ +package dev.kalenchukov.lemna.injection.converters.arrays; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.singles.DoubleConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Double[]}. + */ +public final class ArrayOfDoubleConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Double @Nullable [] convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null) { + return null; + } + + Double[] convertValue = new Double[value.length]; + + for (int elm = 0; elm < value.length; elm++) + { + convertValue[elm] = new DoubleConverter().convert(new String[]{value[elm]}); + } + + return convertValue; + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfFloatConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfFloatConverter.java new file mode 100644 index 0000000..5df786a --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfFloatConverter.java @@ -0,0 +1,34 @@ +package dev.kalenchukov.lemna.injection.converters.arrays; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.singles.FloatConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Float[]}. + */ +public final class ArrayOfFloatConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Float @Nullable [] convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null) { + return null; + } + + Float[] convertValue = new Float[value.length]; + + for (int elm = 0; elm < value.length; elm++) + { + convertValue[elm] = new FloatConverter().convert(new String[]{value[elm]}); + } + + return convertValue; + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfIntegerConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfIntegerConverter.java new file mode 100644 index 0000000..df830bc --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfIntegerConverter.java @@ -0,0 +1,34 @@ +package dev.kalenchukov.lemna.injection.converters.arrays; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.singles.IntegerConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Integer[]}. + */ +public final class ArrayOfIntegerConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Integer @Nullable [] convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null) { + return null; + } + + Integer[] convertValue = new Integer[value.length]; + + for (int elm = 0; elm < value.length; elm++) + { + convertValue[elm] = new IntegerConverter().convert(new String[]{value[elm]}); + } + + return convertValue; + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfLongConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfLongConverter.java new file mode 100644 index 0000000..e9b9708 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfLongConverter.java @@ -0,0 +1,34 @@ +package dev.kalenchukov.lemna.injection.converters.arrays; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.singles.LongConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Long[]}. + */ +public final class ArrayOfLongConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Long @Nullable [] convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null) { + return null; + } + + Long[] convertValue = new Long[value.length]; + + for (int elm = 0; elm < value.length; elm++) + { + convertValue[elm] = new LongConverter().convert(new String[]{value[elm]}); + } + + return convertValue; + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfShortConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfShortConverter.java new file mode 100644 index 0000000..cdf85e5 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfShortConverter.java @@ -0,0 +1,34 @@ +package dev.kalenchukov.lemna.injection.converters.arrays; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.singles.ShortConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Short[]}. + */ +public final class ArrayOfShortConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Short @Nullable [] convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null) { + return null; + } + + Short[] convertValue = new Short[value.length]; + + for (int elm = 0; elm < value.length; elm++) + { + convertValue[elm] = new ShortConverter().convert(new String[]{value[elm]}); + } + + return convertValue; + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfStringConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfStringConverter.java new file mode 100644 index 0000000..054b8a8 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/ArrayOfStringConverter.java @@ -0,0 +1,34 @@ +package dev.kalenchukov.lemna.injection.converters.arrays; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.singles.StringConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code String[]}. + */ +public final class ArrayOfStringConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public String @Nullable [] convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null) { + return null; + } + + String[] convertValue = new String[value.length]; + + for (int elm = 0; elm < value.length; elm++) + { + convertValue[elm] = new StringConverter().convert(new String[]{value[elm]}); + } + + return convertValue; + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/package-info.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/package-info.java new file mode 100644 index 0000000..96aec5d --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/arrays/package-info.java @@ -0,0 +1,7 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.converters.arrays; \ No newline at end of file diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionBooleanConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionBooleanConverter.java new file mode 100644 index 0000000..8af14d1 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionBooleanConverter.java @@ -0,0 +1,39 @@ +package dev.kalenchukov.lemna.injection.converters.collections; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfBooleanConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.*; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Collection} из {@code Boolean}. + */ +public final class CollectionBooleanConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Collection<@NotNull Boolean> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Boolean[] convertValue = new ArrayOfBooleanConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionByteConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionByteConverter.java new file mode 100644 index 0000000..4341317 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionByteConverter.java @@ -0,0 +1,39 @@ +package dev.kalenchukov.lemna.injection.converters.collections; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfByteConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.*; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Collection} из {@code Byte}. + */ +public final class CollectionByteConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Collection<@NotNull Byte> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Byte[] convertValue = new ArrayOfByteConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionCharacterConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionCharacterConverter.java new file mode 100644 index 0000000..8691bb7 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionCharacterConverter.java @@ -0,0 +1,39 @@ +package dev.kalenchukov.lemna.injection.converters.collections; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfCharacterConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.*; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Collection} из {@code Character}. + */ +public final class CollectionCharacterConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Collection<@NotNull Character> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Character[] convertValue = new ArrayOfCharacterConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionDoubleConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionDoubleConverter.java new file mode 100644 index 0000000..5bd6a19 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionDoubleConverter.java @@ -0,0 +1,39 @@ +package dev.kalenchukov.lemna.injection.converters.collections; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfDoubleConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.*; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Collection} из {@code Double}. + */ +public final class CollectionDoubleConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Collection<@NotNull Double> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Double[] convertValue = new ArrayOfDoubleConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionFloatConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionFloatConverter.java new file mode 100644 index 0000000..24ac965 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionFloatConverter.java @@ -0,0 +1,39 @@ +package dev.kalenchukov.lemna.injection.converters.collections; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfFloatConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.*; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Collection} из {@code Float}. + */ +public final class CollectionFloatConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Collection<@NotNull Float> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Float[] convertValue = new ArrayOfFloatConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionIntegerConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionIntegerConverter.java new file mode 100644 index 0000000..81d1e32 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionIntegerConverter.java @@ -0,0 +1,41 @@ +package dev.kalenchukov.lemna.injection.converters.collections; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfIntegerConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.Collection; +import java.util.List; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Collection} из {@code Integer}. + */ +public final class CollectionIntegerConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Collection<@NotNull Integer> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Integer[] convertValue = new ArrayOfIntegerConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionLongConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionLongConverter.java new file mode 100644 index 0000000..24a203c --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionLongConverter.java @@ -0,0 +1,39 @@ +package dev.kalenchukov.lemna.injection.converters.collections; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfLongConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.*; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Collection} из {@code Long}. + */ +public final class CollectionLongConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Collection<@NotNull Long> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Long[] convertValue = new ArrayOfLongConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionShortConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionShortConverter.java new file mode 100644 index 0000000..671b65e --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionShortConverter.java @@ -0,0 +1,39 @@ +package dev.kalenchukov.lemna.injection.converters.collections; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfShortConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.*; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Collection} из {@code Short}. + */ +public final class CollectionShortConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Collection<@NotNull Short> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Short[] convertValue = new ArrayOfShortConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionStringConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionStringConverter.java new file mode 100644 index 0000000..81be2a7 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/CollectionStringConverter.java @@ -0,0 +1,41 @@ +package dev.kalenchukov.lemna.injection.converters.collections; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfStringConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.Collection; +import java.util.List; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Collection} из {@code String}. + */ +public final class CollectionStringConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Collection<@NotNull String> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + String[] convertValue = new ArrayOfStringConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/package-info.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/package-info.java new file mode 100644 index 0000000..c450adb --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/collections/package-info.java @@ -0,0 +1,7 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.converters.collections; \ No newline at end of file diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListBooleanConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListBooleanConverter.java new file mode 100644 index 0000000..2550561 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListBooleanConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.lists; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfBooleanConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code List} из {@code Boolean}. + */ +public final class ListBooleanConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public List<@NotNull Boolean> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Boolean[] convertValue = new ArrayOfBooleanConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListByteConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListByteConverter.java new file mode 100644 index 0000000..412ba8a --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListByteConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.lists; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfByteConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code List} из {@code Byte}. + */ +public final class ListByteConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public List<@NotNull Byte> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Byte[] convertValue = new ArrayOfByteConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListCharacterConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListCharacterConverter.java new file mode 100644 index 0000000..5a94247 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListCharacterConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.lists; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfCharacterConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code List} из {@code Character}. + */ +public final class ListCharacterConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public List<@NotNull Character> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Character[] convertValue = new ArrayOfCharacterConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListDoubleConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListDoubleConverter.java new file mode 100644 index 0000000..1e717ed --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListDoubleConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.lists; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfDoubleConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code List} из {@code Double}. + */ +public final class ListDoubleConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public List<@NotNull Double> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Double[] convertValue = new ArrayOfDoubleConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListFloatConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListFloatConverter.java new file mode 100644 index 0000000..bf6ce57 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListFloatConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.lists; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfFloatConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code List} из {@code Float}. + */ +public final class ListFloatConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public List<@NotNull Float> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Float[] convertValue = new ArrayOfFloatConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListIntegerConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListIntegerConverter.java new file mode 100644 index 0000000..0abca06 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListIntegerConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.lists; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfIntegerConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code List} из {@code Integer}. + */ +public final class ListIntegerConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public List<@NotNull Integer> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Integer[] convertValue = new ArrayOfIntegerConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListLongConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListLongConverter.java new file mode 100644 index 0000000..5a2a457 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListLongConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.lists; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfLongConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code List} из {@code Long}. + */ +public final class ListLongConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public List<@NotNull Long> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Long[] convertValue = new ArrayOfLongConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListShortConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListShortConverter.java new file mode 100644 index 0000000..9d7789d --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListShortConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.lists; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfShortConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code List} из {@code Short}. + */ +public final class ListShortConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public List<@NotNull Short> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Short[] convertValue = new ArrayOfShortConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListStringConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListStringConverter.java new file mode 100644 index 0000000..b5f4f33 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/ListStringConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.lists; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfStringConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code List} из {@code String}. + */ +public final class ListStringConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public List<@NotNull String> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + String[] convertValue = new ArrayOfStringConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/package-info.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/package-info.java new file mode 100644 index 0000000..cce835c --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/lists/package-info.java @@ -0,0 +1,7 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.converters.lists; \ No newline at end of file diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/package-info.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/package-info.java new file mode 100644 index 0000000..8dd2eff --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/package-info.java @@ -0,0 +1,7 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.converters; \ No newline at end of file diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetBooleanConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetBooleanConverter.java new file mode 100644 index 0000000..44ca3c5 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetBooleanConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.sets; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfBooleanConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.Set; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Set} из {@code Boolean}. + */ +public final class SetBooleanConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Set<@NotNull Boolean> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Boolean[] convertValue = new ArrayOfBooleanConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return Set.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetByteConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetByteConverter.java new file mode 100644 index 0000000..b35e701 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetByteConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.sets; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfByteConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.Set; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Set} из {@code Byte}. + */ +public final class SetByteConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Set<@NotNull Byte> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Byte[] convertValue = new ArrayOfByteConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return Set.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetCharacterConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetCharacterConverter.java new file mode 100644 index 0000000..49ba1df --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetCharacterConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.sets; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfCharacterConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.Set; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Set} из {@code Character}. + */ +public final class SetCharacterConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Set<@NotNull Character> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Character[] convertValue = new ArrayOfCharacterConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return Set.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetDoubleConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetDoubleConverter.java new file mode 100644 index 0000000..a61a778 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetDoubleConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.sets; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfDoubleConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.Set; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Set} из {@code Double}. + */ +public final class SetDoubleConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Set<@NotNull Double> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Double[] convertValue = new ArrayOfDoubleConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return Set.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetFloatConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetFloatConverter.java new file mode 100644 index 0000000..4f95cac --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetFloatConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.sets; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfFloatConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.Set; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Set} из {@code Float}. + */ +public final class SetFloatConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Set<@NotNull Float> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Float[] convertValue = new ArrayOfFloatConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return Set.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetIntegerConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetIntegerConverter.java new file mode 100644 index 0000000..7178d9e --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetIntegerConverter.java @@ -0,0 +1,39 @@ +package dev.kalenchukov.lemna.injection.converters.sets; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfIntegerConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.*; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Set} из {@code Integer}. + */ +public final class SetIntegerConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Set<@NotNull Integer> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Integer[] convertValue = new ArrayOfIntegerConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return Set.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetLongConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetLongConverter.java new file mode 100644 index 0000000..2f4ecd4 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetLongConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.sets; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfLongConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.Set; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Set} из {@code Long}. + */ +public final class SetLongConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Set<@NotNull Long> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Long[] convertValue = new ArrayOfLongConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return Set.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetShortConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetShortConverter.java new file mode 100644 index 0000000..c18f60a --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetShortConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.sets; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfShortConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.Set; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Set} из {@code Short}. + */ +public final class SetShortConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Set<@NotNull Short> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + Short[] convertValue = new ArrayOfShortConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return Set.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetStringConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetStringConverter.java new file mode 100644 index 0000000..bb2e7d3 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/SetStringConverter.java @@ -0,0 +1,40 @@ +package dev.kalenchukov.lemna.injection.converters.sets; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.converters.arrays.ArrayOfStringConverter; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.Set; +import java.util.Objects; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Set} из {@code String}. + */ +public final class SetStringConverter implements Converting> +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Set<@NotNull String> convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + String[] convertValue = new ArrayOfStringConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return Set.of(convertValue); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/package-info.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/package-info.java new file mode 100644 index 0000000..c10ea90 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/sets/package-info.java @@ -0,0 +1,7 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.converters.sets; \ No newline at end of file diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/BooleanConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/BooleanConverter.java new file mode 100644 index 0000000..49e3cdf --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/BooleanConverter.java @@ -0,0 +1,31 @@ +package dev.kalenchukov.lemna.injection.converters.singles; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Boolean}. + */ +public final class BooleanConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Boolean convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null || value[0] == null) { + return null; + } + + return switch (value[0].toLowerCase()) + { + case "true" -> true; + case "false" -> false; + default -> throw new UnableConverterException(); + }; + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/ByteConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/ByteConverter.java new file mode 100644 index 0000000..aed6de5 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/ByteConverter.java @@ -0,0 +1,33 @@ +package dev.kalenchukov.lemna.injection.converters.singles; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Byte}. + */ +public final class ByteConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Byte convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null || value[0] == null) { + return null; + } + + try + { + return Byte.parseByte(value[0]); + } + catch (NumberFormatException exception) + { + throw new UnableConverterException(); + } + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/CharacterConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/CharacterConverter.java new file mode 100644 index 0000000..c681297 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/CharacterConverter.java @@ -0,0 +1,33 @@ +package dev.kalenchukov.lemna.injection.converters.singles; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Character}. + */ +public final class CharacterConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Character convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null || value[0] == null) { + return null; + } + + try + { + return value[0].charAt(0); + } + catch (IndexOutOfBoundsException exception) + { + throw new UnableConverterException(); + } + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/DoubleConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/DoubleConverter.java new file mode 100644 index 0000000..4513ff5 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/DoubleConverter.java @@ -0,0 +1,33 @@ +package dev.kalenchukov.lemna.injection.converters.singles; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Double}. + */ +public final class DoubleConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Double convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null || value[0] == null) { + return null; + } + + try + { + return Double.parseDouble(value[0]); + } + catch (NumberFormatException exception) + { + throw new UnableConverterException(); + } + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/FloatConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/FloatConverter.java new file mode 100644 index 0000000..5f1ac78 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/FloatConverter.java @@ -0,0 +1,33 @@ +package dev.kalenchukov.lemna.injection.converters.singles; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Float}. + */ +public final class FloatConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Float convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null || value[0] == null) { + return null; + } + + try + { + return Float.parseFloat(value[0]); + } + catch (NumberFormatException exception) + { + throw new UnableConverterException(); + } + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/IntegerConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/IntegerConverter.java new file mode 100644 index 0000000..58b9ead --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/IntegerConverter.java @@ -0,0 +1,33 @@ +package dev.kalenchukov.lemna.injection.converters.singles; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Integer}. + */ +public final class IntegerConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Integer convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null || value[0] == null) { + return null; + } + + try + { + return Integer.parseInt(value[0]); + } + catch (NumberFormatException exception) + { + throw new UnableConverterException(); + } + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/LongConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/LongConverter.java new file mode 100644 index 0000000..a8bbdbd --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/LongConverter.java @@ -0,0 +1,33 @@ +package dev.kalenchukov.lemna.injection.converters.singles; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Long}. + */ +public final class LongConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Long convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null || value[0] == null) { + return null; + } + + try + { + return Long.parseLong(value[0]); + } + catch (NumberFormatException exception) + { + throw new UnableConverterException(); + } + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/ShortConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/ShortConverter.java new file mode 100644 index 0000000..5164234 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/ShortConverter.java @@ -0,0 +1,33 @@ +package dev.kalenchukov.lemna.injection.converters.singles; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code Short}. + */ +public final class ShortConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public Short convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null || value[0] == null) { + return null; + } + + try + { + return Short.parseShort(value[0]); + } + catch (NumberFormatException exception) + { + throw new UnableConverterException(); + } + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/StringConverter.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/StringConverter.java new file mode 100644 index 0000000..668c564 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/StringConverter.java @@ -0,0 +1,26 @@ +package dev.kalenchukov.lemna.injection.converters.singles; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Класс конвертирует тип данных {@code String[]} в {@code String}. + */ +public final class StringConverter implements Converting +{ + /** + * @see Converting#convert(String[]) + */ + @Override + @Nullable + public String convert(@Nullable final String @Nullable [] value) + throws UnableConverterException + { + if (value == null || value[0] == null) { + return null; + } + + return value[0]; + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/package-info.java b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/package-info.java new file mode 100644 index 0000000..3be12f4 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/converters/singles/package-info.java @@ -0,0 +1,7 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.converters.singles; \ No newline at end of file diff --git a/src/main/java/dev/kalenchukov/lemna/injection/exceptions/IllegalValueException.java b/src/main/java/dev/kalenchukov/lemna/injection/exceptions/IllegalValueException.java new file mode 100644 index 0000000..1e41e2a --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/exceptions/IllegalValueException.java @@ -0,0 +1,27 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.exceptions; + +import org.jetbrains.annotations.NotNull; + +import java.util.Objects; + +/** + * Исключение для некорректного значения для внедрения. + */ +public class IllegalValueException extends RuntimeException +{ + /** + * Конструктор для {@code IllegalValueException}. + * + * @param message Сообщение. + */ + public IllegalValueException(@NotNull final String message) + { + super(Objects.requireNonNull(message)); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/exceptions/InvalidConverterException.java b/src/main/java/dev/kalenchukov/lemna/injection/exceptions/InvalidConverterException.java new file mode 100644 index 0000000..b43e187 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/exceptions/InvalidConverterException.java @@ -0,0 +1,27 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.exceptions; + +import org.jetbrains.annotations.NotNull; + +import java.util.Objects; + +/** + * Исключение для некорректного конвертера значений внедрения. + */ +public class InvalidConverterException extends RuntimeException +{ + /** + * Конструктор для {@code InvalidConverterException}. + * + * @param message Сообщение. + */ + public InvalidConverterException(@NotNull final String message) + { + super(Objects.requireNonNull(message)); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/exceptions/UnableConverterException.java b/src/main/java/dev/kalenchukov/lemna/injection/exceptions/UnableConverterException.java new file mode 100644 index 0000000..9aa6ca0 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/exceptions/UnableConverterException.java @@ -0,0 +1,32 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.exceptions; + +import org.jetbrains.annotations.NotNull; + +import java.util.Objects; + +/** + * Исключение для невозможности конвертирования значения внедрения. + */ +public class UnableConverterException extends RuntimeException +{ + /** + * Конструктор для {@code UnableConverterException}. + */ + public UnableConverterException() {} + + /** + * Конструктор для {@code UnableConverterException}. + * + * @param message Сообщение. + */ + public UnableConverterException(@NotNull final String message) + { + super(Objects.requireNonNull(message)); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/exceptions/UnknownConverterException.java b/src/main/java/dev/kalenchukov/lemna/injection/exceptions/UnknownConverterException.java new file mode 100644 index 0000000..98e92c0 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/exceptions/UnknownConverterException.java @@ -0,0 +1,27 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.exceptions; + +import org.jetbrains.annotations.NotNull; + +import java.util.Objects; + +/** + * Исключение для неопределённого конвертера для значения внедрения. + */ +public class UnknownConverterException extends RuntimeException +{ + /** + * Конструктор для {@code UnknownConverterException}. + * + * @param message Сообщение. + */ + public UnknownConverterException(@NotNull final String message) + { + super(Objects.requireNonNull(message)); + } +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/exceptions/package-info.java b/src/main/java/dev/kalenchukov/lemna/injection/exceptions/package-info.java new file mode 100644 index 0000000..9bda13d --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/exceptions/package-info.java @@ -0,0 +1,7 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.exceptions; \ No newline at end of file diff --git a/src/main/java/dev/kalenchukov/lemna/injection/interfaces/Converting.java b/src/main/java/dev/kalenchukov/lemna/injection/interfaces/Converting.java new file mode 100644 index 0000000..7b1f8ec --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/interfaces/Converting.java @@ -0,0 +1,29 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.interfaces; + +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +/** + * Интерфейс для реализации собственного класса конвертера типа значений. + * + * @param Объект типа возвращаемых данных. + */ +public interface Converting +{ + /** + * Конвертирует значение в указанный тип данных. + * + * @param value Значения, тип данных которых необходимо конвертировать. + * @return Возвращает значение конвертированное в указанный тип данных. + * @throws UnableConverterException Если конвертировать значение в нужный тип данных не удалось. + */ + @Nullable + T convert(@Nullable String @Nullable [] value) + throws UnableConverterException; +} diff --git a/src/main/java/dev/kalenchukov/lemna/injection/interfaces/package-info.java b/src/main/java/dev/kalenchukov/lemna/injection/interfaces/package-info.java new file mode 100644 index 0000000..9a63e33 --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/interfaces/package-info.java @@ -0,0 +1 @@ +package dev.kalenchukov.lemna.injection.interfaces; \ No newline at end of file diff --git a/src/main/java/dev/kalenchukov/lemna/injection/package-info.java b/src/main/java/dev/kalenchukov/lemna/injection/package-info.java new file mode 100644 index 0000000..20243ab --- /dev/null +++ b/src/main/java/dev/kalenchukov/lemna/injection/package-info.java @@ -0,0 +1,7 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection; \ No newline at end of file diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java new file mode 100644 index 0000000..efedbc1 --- /dev/null +++ b/src/main/java/module-info.java @@ -0,0 +1,16 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +module dev.kalenchukov.lemna.injection +{ + requires org.jetbrains.annotations; + requires log4j; + + exports dev.kalenchukov.lemna.injection; + exports dev.kalenchukov.lemna.injection.annotations; + exports dev.kalenchukov.lemna.injection.exceptions; + exports dev.kalenchukov.lemna.injection.interfaces; +} \ No newline at end of file diff --git a/src/main/resources/localizations/exceptions_ru_RU.properties b/src/main/resources/localizations/exceptions_ru_RU.properties new file mode 100644 index 0000000..323cedc --- /dev/null +++ b/src/main/resources/localizations/exceptions_ru_RU.properties @@ -0,0 +1,4 @@ +70001 = Не удалось внедрить значение в поле '%s' класса '%s' +70002 = Не удалось найти конвертер для типа данных '%s' в классе '%s' +70003 = Некорректный конвертер типа данных '%s' в классе '%s' +#70004 = Не удалось конвертировать значение в необходимый тип данных \ No newline at end of file diff --git a/src/main/resources/localizations/logs_ru_RU.properties b/src/main/resources/localizations/logs_ru_RU.properties new file mode 100644 index 0000000..ad79260 --- /dev/null +++ b/src/main/resources/localizations/logs_ru_RU.properties @@ -0,0 +1,10 @@ +60001 = Запущено внедрение значений в поля класса '%s' +60002 = Завершено внедрение значений в поля класса '%s' +60003 = Не найдено значение для поля '%s' +60004 = Внедрение в поле '%s' завершено +60005 = Найден персональный конвертер '%s' для типа данных '%s' +60006 = +60007 = +60008 = +60009 = +60010 = diff --git a/src/main/resources/log4j.properties b/src/main/resources/log4j.properties new file mode 100644 index 0000000..709fe5f --- /dev/null +++ b/src/main/resources/log4j.properties @@ -0,0 +1,17 @@ +# +# Copyright © 2022 Алексей Каленчуков +# GitHub: https://github.com/kalenchukov +# E-mail: mailto:aleksey.kalenchukov@yandex.ru +# + +# Уровень логирования +log4j.rootLogger = DEBUG, CONSOLE + +# Апендер для работы с файлами +log4j.appender.CONSOLE = org.apache.log4j.ConsoleAppender + +# Конфигурируем шаблон вывода логов в файл +log4j.appender.CONSOLE.layout = org.apache.log4j.PatternLayout + +# Шаблон записи +log4j.appender.CONSOLE.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss,SSS} %-10p %-30c{1}:%-4L - %m%n diff --git a/src/test/java/dev/kalenchukov/lemna/injection/InjectionTest.java b/src/test/java/dev/kalenchukov/lemna/injection/InjectionTest.java new file mode 100644 index 0000000..b6dbd65 --- /dev/null +++ b/src/test/java/dev/kalenchukov/lemna/injection/InjectionTest.java @@ -0,0 +1,620 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection; + +import dev.kalenchukov.lemna.injection.annotations.Converter; +import dev.kalenchukov.lemna.injection.exceptions.InvalidConverterException; +import dev.kalenchukov.lemna.injection.exceptions.IllegalValueException; +import dev.kalenchukov.lemna.injection.exceptions.UnknownConverterException; +import dev.kalenchukov.lemna.injection.supports.*; +import org.junit.Test; + +import java.util.*; + +import static org.junit.Assert.*; + +public class InjectionTest +{ + /** + * Проверка внедрения в одиночные типы данных. + */ + @Test + public void testInject1() + { + class Experimental + { + public Integer var1; + public Short var2; + public Float var3; + public Double var4; + public Long var5; + public String var6; + public Character var7; + public Boolean var8; + public Byte var9; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"1"}); + data.put("var2", new String[]{"2"}); + data.put("var3", new String[]{"3.0"}); + data.put("var4", new String[]{"4.59"}); + data.put("var5", new String[]{"1698756"}); + data.put("var6", new String[]{"text"}); + data.put("var7", new String[]{"A"}); + data.put("var8", new String[]{"true"}); + data.put("var9", new String[]{"27"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertEquals(Integer.valueOf(1), experimental.var1); + assertEquals(Short.valueOf((short) 2), experimental.var2); + assertEquals(Float.valueOf(3.0F), experimental.var3); + assertEquals(Double.valueOf(4.59), experimental.var4); + assertEquals(Long.valueOf(1698756L), experimental.var5); + assertEquals("text", experimental.var6); + assertEquals(Character.valueOf('A'), experimental.var7); + assertEquals(true, experimental.var8); + assertEquals(Byte.valueOf((byte) 27), experimental.var9); + } + + /** + * Проверка внедрения в массивы одиночных типов данных. + */ + @Test + public void testInject2() + { + class Experimental + { + public Integer[] var1; + public Short[] var2; + public Float[] var3; + public Double[] var4; + public Long[] var5; + public String[] var6; + public Character[] var7; + public Boolean[] var8; + public Byte[] var9; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"1", "11", null}); + data.put("var2", new String[]{"2", "22", null}); + data.put("var3", new String[]{"3.0", "3.30", null}); + data.put("var4", new String[]{"4.59", "59.40", null}); + data.put("var5", new String[]{"1698756", "345345346", null}); + data.put("var6", new String[]{"text", "TEXT", null}); + data.put("var7", new String[]{"A", "B", null}); + data.put("var8", new String[]{"true", "false", null}); + data.put("var9", new String[]{"27", "45", null}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertArrayEquals(new Integer[]{1, 11, null}, experimental.var1); + assertArrayEquals(new Short[]{2, 22, null}, experimental.var2); + assertArrayEquals(new Float[]{3.0F, 3.30F, null}, experimental.var3); + assertArrayEquals(new Double[]{4.59, 59.40, null}, experimental.var4); + assertArrayEquals(new Long[]{1698756L, 345345346L, null}, experimental.var5); + assertArrayEquals(new String[] {"text", "TEXT", null}, experimental.var6); + assertArrayEquals(new Character[]{'A', 'B', null}, experimental.var7); + assertArrayEquals(new Boolean[]{true, false, null}, experimental.var8); + assertArrayEquals(new Byte[]{27, 45, null}, experimental.var9); + } + + /** + * Проверка внедрения в {@code Collection} типы данных. + */ + @Test + public void testInject3() + { + class Experimental + { + public Collection var1; + public Collection var2; + public Collection var3; + public Collection var4; + public Collection var5; + public Collection var6; + public Collection var7; + public Collection var8; + public Collection var9; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"1", "11", "11"}); + data.put("var2", new String[]{"2", "22", "22"}); + data.put("var3", new String[]{"3.0", "3.30", "3.30"}); + data.put("var4", new String[]{"4.59", "59.40", "59.40"}); + data.put("var5", new String[]{"1698756", "345345346", "345345346"}); + data.put("var6", new String[]{"text", "TEXT", "TEXT"}); + data.put("var7", new String[]{"A", "B", "B"}); + data.put("var8", new String[]{"true", "false", "false"}); + data.put("var9", new String[]{"27", "45", "45"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertEquals(List.of(new Integer[]{1, 11, 11}), experimental.var1); + assertEquals(List.of(new Short[]{2, 22, 22}), experimental.var2); + assertEquals(List.of(new Float[]{3.0F, 3.30F, 3.30F}), experimental.var3); + assertEquals(List.of(new Double[]{4.59, 59.40, 59.40}), experimental.var4); + assertEquals(List.of(new Long[]{1698756L, 345345346L, 345345346L}), experimental.var5); + assertEquals(List.of(new String[] {"text", "TEXT", "TEXT"}), experimental.var6); + assertEquals(List.of(new Character[]{'A', 'B', 'B'}), experimental.var7); + assertEquals(List.of(new Boolean[]{true, false, false}), experimental.var8); + assertEquals(List.of(new Byte[]{27, 45, 45}), experimental.var9); + } + + /** + * Проверка внедрения в {@code List} типы данных. + */ + @Test + public void testInject4() + { + class Experimental + { + public List var1; + public List var2; + public List var3; + public List var4; + public List var5; + public List var6; + public List var7; + public List var8; + public List var9; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"1", "11", "11"}); + data.put("var2", new String[]{"2", "22", "22"}); + data.put("var3", new String[]{"3.0", "3.30", "3.30"}); + data.put("var4", new String[]{"4.59", "59.40", "59.40"}); + data.put("var5", new String[]{"1698756", "345345346", "345345346"}); + data.put("var6", new String[]{"text", "TEXT", "TEXT"}); + data.put("var7", new String[]{"A", "B", "B"}); + data.put("var8", new String[]{"true", "false", "false"}); + data.put("var9", new String[]{"27", "45", "45"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertEquals(List.of(new Integer[]{1, 11, 11}), experimental.var1); + assertEquals(List.of(new Short[]{2, 22, 22}), experimental.var2); + assertEquals(List.of(new Float[]{3.0F, 3.30F, 3.30F}), experimental.var3); + assertEquals(List.of(new Double[]{4.59, 59.40, 59.40}), experimental.var4); + assertEquals(List.of(new Long[]{1698756L, 345345346L, 345345346L}), experimental.var5); + assertEquals(List.of(new String[] {"text", "TEXT", "TEXT"}), experimental.var6); + assertEquals(List.of(new Character[]{'A', 'B', 'B'}), experimental.var7); + assertEquals(List.of(new Boolean[]{true, false, false}), experimental.var8); + assertEquals(List.of(new Byte[]{27, 45, 45}), experimental.var9); + } + + /** + * Проверка внедрения в {@code Set} типы данных. + */ + @Test + public void testInject5() + { + class Experimental + { + public Set var1; + public Set var2; + public Set var3; + public Set var4; + public Set var5; + public Set var6; + public Set var7; + public Set var8; + public Set var9; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"1", "11"}); + data.put("var2", new String[]{"2", "22"}); + data.put("var3", new String[]{"3.0", "3.30"}); + data.put("var4", new String[]{"4.59", "59.40"}); + data.put("var5", new String[]{"1698756", "345345346"}); + data.put("var6", new String[]{"text", "TEXT"}); + data.put("var7", new String[]{"A", "B"}); + data.put("var8", new String[]{"true", "false"}); + data.put("var9", new String[]{"27", "45"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertEquals(Set.of(new Integer[]{1, 11}), experimental.var1); + assertEquals(Set.of(new Short[]{2, 22}), experimental.var2); + assertEquals(Set.of(new Float[]{3.0F, 3.30F}), experimental.var3); + assertEquals(Set.of(new Double[]{4.59, 59.40}), experimental.var4); + assertEquals(Set.of(new Long[]{1698756L, 345345346L}), experimental.var5); + assertEquals(Set.of(new String[] {"text", "TEXT"}), experimental.var6); + assertEquals(Set.of(new Character[]{'A', 'B'}), experimental.var7); + assertEquals(Set.of(new Boolean[]{true, false}), experimental.var8); + assertEquals(Set.of(new Byte[]{27, 45}), experimental.var9); + } + + /** + * Проверка внедрения {@code null} в {@code Collection}. + */ + @Test(expected = IllegalValueException.class) + public void testInject6() + { + class Experimental + { + public Collection var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{null}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + } + + /** + * Проверка внедрения {@code null} в {@code List}. + */ + @Test(expected = IllegalValueException.class) + public void testInject7() + { + class Experimental + { + public List var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{null}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + } + + /** + * Проверка внедрения {@code null} в {@code Set}. + */ + @Test(expected = IllegalValueException.class) + public void testInject8() + { + class Experimental + { + public Set var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{null}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + } + + /** + * Проверка внедрения в дублирующих значений в {@code Set}. + */ + @Test(expected = IllegalValueException.class) + public void testInject9() + { + class Experimental + { + public Set var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"qwe", "qwe"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + } + + /** + * Проверка внедрения в примитивные типы данных. + */ + @Test(expected = UnknownConverterException.class) + public void testInject10() + { + class Experimental + { + public int var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"1"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + } + + /** + * Проверка внедрения в тип данных {@code Gender} с помощью собственного конвертера. + */ + @Test() + public void testInject11() + { + class Experimental + { + @Converter(converter = SingleGenderConverter.class) + public Gender var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"M"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertEquals(Gender.M, experimental.var1); + } + + /** + * Проверка внедрения {@code null} в тип данных {@code Gender} с помощью собственного конвертера. + */ + @Test() + public void testInject12() + { + class Experimental + { + @Converter(converter = SingleGenderConverter.class) + public Gender var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{null}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertNull(experimental.var1); + } + + /** + * Проверка внедрения {@code null} в тип данных {@code Gender} с помощью собственного конвертера. + */ + @Test() + public void testInject13() + { + class Experimental + { + @Converter(converter = SingleGenderConverter.class) + public Gender var1; + } + + Map data = new HashMap<>(); + data.put("var1", null); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertNull(experimental.var1); + } + + /** + * Проверка использования неподходящего собственного конвертера типа данных. + */ + @Test(expected = InvalidConverterException.class) + public void testInject14() + { + class Experimental + { + @Converter(converter = SingleGenderConverter.class) + public Gender[] var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"M", "F"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertArrayEquals(new Gender[]{Gender.M, Gender.F}, experimental.var1); + } + + /** + * Проверка внедрения в тип данных {@code Gender[]} с помощью собственного конвертера. + */ + @Test + public void testInject15() + { + class Experimental + { + @Converter(converter = ArrayOfGenderConverter.class) + public Gender[] var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"M", "F", null}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertArrayEquals(new Gender[]{Gender.M, Gender.F, null}, experimental.var1); + } + + /** + * Проверка внедрения своего типа данных {@code Gender} в коллекцию {@code Collection}. + */ + @Test + public void testInject16() + { + class Experimental + { + @Converter(converter = CollectionOfGenderConverter.class) + public Collection var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"M", "F"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertEquals(List.of(new Gender[]{Gender.M, Gender.F}), experimental.var1); + } + + /** + * Проверка внедрения своего типа данных {@code Gender} в коллекцию {@code List}. + */ + @Test + public void testInject17() + { + class Experimental + { + @Converter(converter = ListOfGenderConverter.class) + public List var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"M", "F"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertEquals(List.of(new Gender[]{Gender.M, Gender.F}), experimental.var1); + } + + /** + * Проверка внедрения своего типа данных {@code Gender} в коллекцию {@code Set}. + */ + @Test + public void testInject18() + { + class Experimental + { + @Converter(converter = SetOfGenderConverter.class) + public Set var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"M", "F"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertEquals(Set.of(new Gender[]{Gender.M, Gender.F}), experimental.var1); + } + + /** + * Проверка внедрения дублирующих значений {@code Gender} в коллекцию {@code Set}. + */ + @Test(expected = IllegalValueException.class) + public void testInject19() + { + class Experimental + { + @Converter(converter = SetOfGenderConverter.class) + public Set var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"M", "F", "F"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + } + + /** + * Проверка внедрения {@code null} в коллекцию {@code List} из своего типа данных {@code Gender}. + */ + @Test(expected = IllegalValueException.class) + public void testInject20() + { + class Experimental + { + @Converter(converter = ListOfGenderConverter.class) + public List var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"M", "F", null}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + } + + /** + * Проверка внедрения в поле с неизвестным типом данных. + * В качестве неизвестного типа данных коллекция {@code List} из {@code String[]}, + * для которого нет стандартного конвертера. + */ + @Test(expected = UnknownConverterException.class) + public void testInject21() + { + class Experimental + { + public List var1; + } + + Map data = new HashMap<>(); + data.put("var1", new String[]{"QWE"}); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + } + + /** + * Проверка внедрения без данных. + */ + @Test() + public void testInject22() + { + class Experimental + { + public String var1; + } + + Map data = new HashMap<>(); + + Experimental experimental = new Experimental(); + + Injectable injector = new Injection(experimental); + injector.inject(data); + + assertNull(experimental.var1); + } +} \ No newline at end of file diff --git a/src/test/java/dev/kalenchukov/lemna/injection/supports/ArrayOfGenderConverter.java b/src/test/java/dev/kalenchukov/lemna/injection/supports/ArrayOfGenderConverter.java new file mode 100644 index 0000000..2b1e4ee --- /dev/null +++ b/src/test/java/dev/kalenchukov/lemna/injection/supports/ArrayOfGenderConverter.java @@ -0,0 +1,33 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.supports; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +public class ArrayOfGenderConverter implements Converting +{ + @Nullable + @Override + public Gender @Nullable [] convert(@Nullable String @Nullable [] value) + throws UnableConverterException + { + if (value == null) { + return null; + } + + Gender[] convertValue = new Gender[value.length]; + + for (int elm = 0; elm < value.length; elm++) + { + convertValue[elm] = new SingleGenderConverter().convert(new String[]{value[elm]}); + } + + return convertValue; + } +} diff --git a/src/test/java/dev/kalenchukov/lemna/injection/supports/CollectionOfGenderConverter.java b/src/test/java/dev/kalenchukov/lemna/injection/supports/CollectionOfGenderConverter.java new file mode 100644 index 0000000..f6c79b4 --- /dev/null +++ b/src/test/java/dev/kalenchukov/lemna/injection/supports/CollectionOfGenderConverter.java @@ -0,0 +1,37 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.supports; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.*; + +public class CollectionOfGenderConverter implements Converting> +{ + @Nullable + @Override + public Collection<@NotNull Gender> convert(@Nullable String @Nullable [] value) + throws UnableConverterException + { + Gender[] convertValue = new ArrayOfGenderConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/test/java/dev/kalenchukov/lemna/injection/supports/Gender.java b/src/test/java/dev/kalenchukov/lemna/injection/supports/Gender.java new file mode 100644 index 0000000..3f61967 --- /dev/null +++ b/src/test/java/dev/kalenchukov/lemna/injection/supports/Gender.java @@ -0,0 +1,13 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.supports; + +public enum Gender +{ + M, + F; +} diff --git a/src/test/java/dev/kalenchukov/lemna/injection/supports/ListOfGenderConverter.java b/src/test/java/dev/kalenchukov/lemna/injection/supports/ListOfGenderConverter.java new file mode 100644 index 0000000..9a0b45b --- /dev/null +++ b/src/test/java/dev/kalenchukov/lemna/injection/supports/ListOfGenderConverter.java @@ -0,0 +1,39 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.supports; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; + +public class ListOfGenderConverter implements Converting> +{ + @Nullable + @Override + public List<@NotNull Gender> convert(@Nullable String @Nullable [] value) + throws UnableConverterException + { + Gender[] convertValue = new ArrayOfGenderConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return List.of(convertValue); + } +} diff --git a/src/test/java/dev/kalenchukov/lemna/injection/supports/SetOfGenderConverter.java b/src/test/java/dev/kalenchukov/lemna/injection/supports/SetOfGenderConverter.java new file mode 100644 index 0000000..70870d0 --- /dev/null +++ b/src/test/java/dev/kalenchukov/lemna/injection/supports/SetOfGenderConverter.java @@ -0,0 +1,39 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.supports; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; +import java.util.Objects; +import java.util.Set; + +public class SetOfGenderConverter implements Converting> +{ + @Nullable + @Override + public Set<@NotNull Gender> convert(@Nullable String @Nullable [] value) + throws UnableConverterException + { + Gender[] convertValue = new ArrayOfGenderConverter().convert(value); + + if (convertValue == null) { + return null; + } + + boolean has = Arrays.stream(convertValue).anyMatch(Objects::isNull); + + if (has) { + throw new UnableConverterException(); + } + + return Set.of(convertValue); + } +} diff --git a/src/test/java/dev/kalenchukov/lemna/injection/supports/SingleGenderConverter.java b/src/test/java/dev/kalenchukov/lemna/injection/supports/SingleGenderConverter.java new file mode 100644 index 0000000..c267924 --- /dev/null +++ b/src/test/java/dev/kalenchukov/lemna/injection/supports/SingleGenderConverter.java @@ -0,0 +1,34 @@ +/* + * Copyright © 2022 Алексей Каленчуков + * GitHub: https://github.com/kalenchukov + * E-mail: mailto:aleksey.kalenchukov@yandex.ru + */ + +package dev.kalenchukov.lemna.injection.supports; + +import dev.kalenchukov.lemna.injection.interfaces.Converting; +import dev.kalenchukov.lemna.injection.exceptions.UnableConverterException; +import org.jetbrains.annotations.Nullable; + +public class SingleGenderConverter implements Converting +{ + @Nullable + @Override + public Gender convert(@Nullable String @Nullable [] value) + throws UnableConverterException + { + if (value == null || value[0] == null) { + return null; + } + + try + { + return Gender.valueOf(value[0]); + } + catch (IllegalArgumentException exception) + { + throw new UnableConverterException(); + } + + } +}