[code=Java]public class DataObject implements Comparable<DataObject> {
private final String name;
/**
* default constructor <br>
*
* @param name
*/
public DataObject(@NonNull String name) {
log.debug("create a new {} object", DataObject.class.getSimpleName());
this.name = name;
}
@Override
public int compareTo(@NonNull DataObject dataObject) {
return name.compareTo(dataObject.name);
}
@Override
public int hashCode() {
return 31 + name.hashCode();
}
@Override
public boolean equals(@NonNull Object object) {
DataObject dataObject = (DataObject) object;
return name.equals(dataObject.name);
}
@Override
public String toString() {
return name;
}
}[/code]
[code=Java]@Slf4j
public abstract class SportsObject extends DataObject{
/**
* default constructor <br>
*
* @param name
*/
public <T extends SportsObject> SportsObject(@NonNull String name) {
super(name);
log.debug("create a new {} object", VolleyballListObject.class.getSimpleName());
}
/**
* update the element <br>
*
* @param element
*/
public abstract <T extends SportsObject> void updateElement(@NonNull T element);
}
[/code]
[code=Java]public abstract class SportsListObject extends SportsObject {
@Getter(AccessLevel.NONE)
private Set<Class<?>> acceptedElementType = Sets.newHashSet();
@Getter(AccessLevel.NONE)
private List<SportsObject> elementList = Lists.newArrayList();
/**
* default constructor <br>
*
* @param name
*/
public SportsListObject(@NonNull String name) {
super(name);
log.debug("create a new {} object", SportsListObject.class.getSimpleName());
}
/**
* add the element class to the acceptedElementType list <br<
*
* @param list
*/
protected void acceptedElementType(List<Class<?>> list) {
for (Class<?> type : list) {
log.debug("accept {} ", type.getSimpleName());
acceptedElementType.add(type);
}
}
/**
* add the list elements to the elementList <br>
* check if the element class is accepted <br>
* update the list element if it exists already <br>
*
* @param elements
*/
public <T extends SportsObject> void addElement(@NonNull List<T> elements) {
for (T element : elements) {
if (acceptedElementType.contains(element.getClass())) {
// check if the element exists already
Optional<SportsObject> optional = elementList.stream().filter(e -> e.equals(element)).findFirst();
if (optional.isPresent()) {
// update the existing element
optional.get().updateElement(element);
} else {
// add the element to the element list
log.debug("add the {}", element);
elementList.add(element);
}
} else {
log.warn("the class {} is not supported ", element, element.getClass().getSimpleName());
}
}
}
/**
* remove the elements of the list to the elementList <br>
* check if the element class is accepted <br>
* remove the list element if it exists <br>
*
* @param elements
*/
public <T extends SportsObject> void removeElement(@NonNull List<T> elements) {
for (T element : elements) {
if (acceptedElementType.contains(element.getClass())) {
// check if the element exists already
Optional<SportsObject> optional = elementList.stream().filter(e -> e.equals(element)).findFirst();
if (optional.isPresent()) {
// remove the existing element
log.debug("remove the {}", element);
elementList.remove(optional.get());
} else {
log.debug("the element {} was not found", element);
}
} else {
log.warn("the class {} is not supported ", element, element.getClass().getSimpleName());
}
}
}
/**
* @param elementType
* @return a list with elements of the appropriate type <br>
*/
@SuppressWarnings("unchecked")
protected <T extends SportsObject> List<T> getElementOf(@NonNull Class<T> elementType) {
return (List<T>) elementList.stream().filter(e -> e.getClass().equals(elementType))
.collect(Collectors.toList());
}
}[/code]
