001package com.box.sdkgen.serialization.json;
002
003import java.util.Collections;
004import java.util.List;
005import java.util.Objects;
006import java.util.stream.Collectors;
007
008public class EnumWrapper<E extends Enum<E> & Valuable> implements Valuable {
009  private E value;
010  private final String stringValue;
011
012  public EnumWrapper(E enumValue) {
013    this.stringValue = enumValue.getValue();
014    this.value = enumValue;
015  }
016
017  public EnumWrapper(String value) {
018    this.stringValue = value;
019  }
020
021  public E getEnumValue() {
022    return value;
023  }
024
025  public String getStringValue() {
026    return stringValue;
027  }
028
029  @Override
030  public String getValue() {
031    return stringValue;
032  }
033
034  @Override
035  public String toString() {
036    return "EnumWrapper{" + "value=" + value + ", stringValue='" + stringValue + '\'' + '}';
037  }
038
039  @Override
040  public boolean equals(Object o) {
041    if (this == o) {
042      return true;
043    }
044    if (o == null || getClass() != o.getClass()) {
045      return false;
046    }
047    EnumWrapper<?> casted = (EnumWrapper<?>) o;
048    return Objects.equals(stringValue, casted.stringValue);
049  }
050
051  @Override
052  public int hashCode() {
053    return Objects.hash(stringValue);
054  }
055
056  public static <T extends Enum<T> & Valuable> List<EnumWrapper<T>> wrapValuableEnumList(
057      List<? extends Valuable> listField, Class<T> enumType) {
058    if (listField == null || listField.isEmpty()) {
059      return Collections.emptyList();
060    }
061    return listField.stream()
062        .map(
063            field -> {
064              if (field instanceof EnumWrapper) {
065                return (EnumWrapper<T>) field;
066              } else if (field.getClass().isAssignableFrom(enumType)) {
067                return new EnumWrapper<>(enumType.cast(field));
068              } else {
069                throw new IllegalArgumentException("Unsupported type: " + field.getClass());
070              }
071            })
072        .collect(Collectors.toList());
073  }
074
075  public static <T extends Enum<T> & Valuable>
076      List<List<EnumWrapper<T>>> wrapValuableEnumListOfLists(
077          List<List<? extends Valuable>> listOfLists, Class<T> enumType) {
078    if (listOfLists == null || listOfLists.isEmpty()) {
079      return Collections.emptyList();
080    }
081    return listOfLists.stream()
082        .map(list -> wrapValuableEnumList(list, enumType))
083        .collect(Collectors.toList());
084  }
085
086  public static <T extends Enum<T> & Valuable> List<EnumWrapper<T>> wrapListOfEnums(List<T> enums) {
087    return enums.stream().map(EnumWrapper::new).collect(Collectors.toList());
088  }
089
090  public static <T extends Enum<T> & Valuable> List<List<EnumWrapper<T>>> wrapListOfListsOfEnums(
091      List<List<T>> listOfEnums) {
092    return listOfEnums.stream().map(EnumWrapper::wrapListOfEnums).collect(Collectors.toList());
093  }
094
095  public static <T extends Enum<T> & Valuable> String convertToString(EnumWrapper<T> enumValue) {
096    if (enumValue == null) {
097      return null;
098    }
099    return enumValue.getStringValue();
100  }
101
102  public static <T extends Enum<T> & Valuable> List<String> convertToString(
103      List<EnumWrapper<T>> enumValue) {
104    if (enumValue == null) {
105      return null;
106    }
107    return enumValue.stream().map(EnumWrapper::getStringValue).collect(Collectors.toList());
108  }
109}