public interface Converter<D extends BaseDto, E extends BaseEntity> {

  default E convertDto(D dto) {
    return convertDto(dto, false);
  }

  E convertDto(D dto, boolean full);

  default Stream<E> convertDto(Set<D> dtos, boolean full) {
    return Stream.ofNullable(dtos)
        .flatMap(Collection::stream)
        .map(dto -> convertDto(dto, full));
  }

  default D convertEntity(E entity) {
    return convertEntity(entity, false);
  }

  D convertEntity(E entity, boolean full);

  default Set<D> convertEntity(Set<E> entities, boolean full) {
    return Stream.ofNullable(entities)
        .flatMap(Collection::stream)
        .map(entity -> convertEntity(entity, full))
        .collect(Collectors.toSet());
  }

  default E updateEntity(E entity, D dto, boolean full) {
    throw new UnsupportedOperationException("Current operation doesn't support");
  }

  default Stream<E> updateEntity(Set<D> dtos, Set<E> entities, boolean full) {
    return dtos.stream()
        .map(dto -> updateEntity(findEntity(entities, dto.getId()), dto, full));
  }

  private E findEntity(Set<E> entities, UUID uuid) {
    return entities.stream()
        .filter(limitSignatureEntity -> Objects.equals(limitSignatureEntity.getId(), uuid))
        .findAny()
        .orElse(null);
  }
}