/** * Provides utility methods for mathematics. */ @Reusable public final class MathUtils { @Inject MathUtils() { } public float toMiles(float meters) { return meters * 0.000621371f; } }
/** * An {@link Executor} that simply runs any runnable it is given. */ @Reusable final class BlockingExecutor implements Executor { @Inject BlockingExecutor() { } @Override public void execute(@NonNull Runnable runnable) { runnable.run(); } }
/** * Uses {@link System#in} forprompting input from the input stream. */ @Reusable final class DisplayInput { @Inject DisplayInput() { } String getInput() { Scanner scanner = new Scanner(System.in, "UTF-8"); return scanner.nextLine().trim(); } }
/** * Android implementation of {@link NetworkStatus}. */ @Reusable final class DeviceNetworkStatus implements NetworkStatus { @Inject DeviceNetworkStatus() { } @Override public boolean hasNetworkConnectivity() { // TODO (IMPLEMENTATION) - nogui hasNetworkConnectivity return true; } }
/** * Creates instances of {@link BusinessObserver}. */ @Reusable public final class BusinessObserverFactory { private final ModelMapperHolder modelMapperHolder; @Inject BusinessObserverFactory(ModelMapperHolder modelMapperHolder) { this.modelMapperHolder = modelMapperHolder; } public BusinessObserver create(BusinessView view) { return new BusinessObserver(view, modelMapperHolder); } }
/** * Creates instances of {@link Calendar} with a {@link Locale}. */ @Reusable public final class CalendarFactory { private final Locale locale; @Inject CalendarFactory(Locale locale) { this.locale = locale; } public Calendar create() { return Calendar.getInstance(locale); } }
/** * An {@link ExecutionThread} that provides a scheduler to the current thread. */ @Reusable final class BlockingExecutionThread implements ExecutionThread { private final BlockingExecutor blockingExecutor; @Inject BlockingExecutionThread(BlockingExecutor blockingExecutor) { this.blockingExecutor = blockingExecutor; } @Override public Scheduler scheduler() { return Schedulers.from(blockingExecutor); } }
/** * a {@link PostExecutionThread} that provides a scheduler to the current thread. */ @Reusable final class BlockingPostExecutionThread implements PostExecutionThread { private final BlockingExecutor blockingExecutor; @Inject BlockingPostExecutionThread(BlockingExecutor blockingExecutor) { this.blockingExecutor = blockingExecutor; } @Override public Scheduler scheduler() { return Schedulers.from(blockingExecutor); } }
/** * Validation for {@link CoordinatesEntity} */ @Reusable final class CoordinatesEntityValidator implements EntityValidator<CoordinatesEntity> { @Inject CoordinatesEntityValidator() { } @Override public void validate(CoordinatesEntity coordinatesEntity) throws InvalidEntityException { if (!isValid(coordinatesEntity)) { throw new InvalidEntityException("Latitude and longitude must not be 0."); } } @Override public boolean isValid(CoordinatesEntity coordinatesEntity) { return coordinatesEntity.latitude() != 0 && coordinatesEntity.longitude() != 0; } }
/** * Validation for {@link LocationEntity}. */ @Reusable final class LocationEntityValidator implements EntityValidator<LocationEntity> { private final StringUtils stringUtils; @Inject LocationEntityValidator(StringUtils stringUtils) { this.stringUtils = stringUtils; } @Override public void validate(LocationEntity locationEntity) throws InvalidEntityException { if (!isValid(locationEntity)) { throw new InvalidEntityException("One or more attributes must not be null or empty."); } } @Override public boolean isValid(LocationEntity locationEntity) { return !stringUtils.allEmpty(locationEntity.address(), locationEntity.city(), locationEntity.state(), locationEntity.zipCode(), locationEntity.country()); } }
/** * Maps {@link CoordinatesEntity} to {@link Coordinates} and vice versa. */ @Reusable final class CoordinatesEntityMapper implements EntityMapper<CoordinatesEntity, Coordinates> { @Inject CoordinatesEntityMapper() { } @Override public Coordinates map(CoordinatesEntity coordinatesEntity) { return Coordinates.builder() .latitude(coordinatesEntity.latitude()) .longitude(coordinatesEntity.longitude()) .build(); } @Override public CoordinatesEntity map(Coordinates coordinates) { return CoordinatesEntity.builder() .latitude(coordinates.latitude()) .longitude(coordinates.longitude()) .build(); } }
/** * Maps {@link CoordinatesModel} to {@link Coordinates} and vice versa. */ @Reusable final class CoordinatesModelMapper implements ModelMapper<CoordinatesModel, Coordinates> { @Inject CoordinatesModelMapper() { } @Override public Coordinates map(CoordinatesModel coordinatesModel) { return Coordinates.builder() .latitude(coordinatesModel.latitude()) .longitude(coordinatesModel.longitude()) .build(); } @Override public CoordinatesModel map(Coordinates coordinates) { return CoordinatesModel.builder() .latitude(coordinates.latitude()) .longitude(coordinates.longitude()) .build(); } }
/** * Maps a business day, whose first day of the week is a {@link Calendar#MONDAY}, to a * {@link Calendar#DAY_OF_WEEK}, whose first day of the week is a {@link Calendar#SUNDAY}. */ @Reusable public final class BusinessDayToDayOfWeekMapper { private static final List<Integer> DAY_OF_WEEK; static { DAY_OF_WEEK = new ArrayList<>(7); DAY_OF_WEEK.add(Calendar.MONDAY); DAY_OF_WEEK.add(Calendar.TUESDAY); DAY_OF_WEEK.add(Calendar.WEDNESDAY); DAY_OF_WEEK.add(Calendar.THURSDAY); DAY_OF_WEEK.add(Calendar.FRIDAY); DAY_OF_WEEK.add(Calendar.SATURDAY); DAY_OF_WEEK.add(Calendar.SUNDAY); } @Inject BusinessDayToDayOfWeekMapper() { } public int map(int businessDay) { return DAY_OF_WEEK.get(businessDay); } }
/** * Maps {@link BusinessHourModel} to {@link BusinessHour} and vice versa. */ @Reusable final class BusinessHourModelMapper implements ModelMapper<BusinessHourModel, BusinessHour> { @Inject BusinessHourModelMapper() { } @Override public BusinessHour map(BusinessHourModel businessHourModel) { return BusinessHour.builder() .day(businessHourModel.day()) .start(businessHourModel.start()) .end(businessHourModel.end()) .build(); } @Override public BusinessHourModel map(BusinessHour businessHour) { return BusinessHourModel.builder() .day(businessHour.day()) .start(businessHour.start()) .end(businessHour.end()) .build(); } }
/** * Maps lists of models. */ @Reusable final class ModelListMapper { @Inject ModelListMapper() { } <K extends Model, V extends DomainObject> List<V> mapToV(ModelMapper<K, V> modelMapper, List<K> kList) { List<V> vList = new ArrayList<>(kList.size()); for (K k : kList) { vList.add(modelMapper.map(k)); } return vList; } <K extends Model, V extends DomainObject> List<K> mapToK(ModelMapper<K, V> modelMapper, List<V> vList) { List<K> kList = new ArrayList<>(vList.size()); for (V v : vList) { kList.add(modelMapper.map(v)); } return kList; } }
@Reusable public final class EntityValidatorHolder {
@Reusable public final class BusinessDataStoreFactory {
/** * Maps {@link BusinessHourEntity} to {@link BusinessHour} and vice versa. */ @Reusable final class BusinessHourEntityMapper implements EntityMapper<BusinessHourEntity, BusinessHour> { @Inject BusinessHourEntityMapper() { } @Override public BusinessHour map(BusinessHourEntity businessHourEntity) { return BusinessHour.builder() .day(businessHourEntity.day()) .start(businessHourEntity.start()) .end(businessHourEntity.end()) .build(); } @Override public BusinessHourEntity map(BusinessHour businessHour) { return BusinessHourEntity.builder() .day(businessHour.day()) .start(businessHour.start()) .end(businessHour.end()) .build(); } }
@Binds @Reusable abstract EntityMapper<BusinessTransactionTypeEntity, BusinessTransactionType> businessTransactionTypeEntityMapper(BusinessTransactionTypeEntityMapper businessTransactionTypeEntityMapper);
@Binds @Reusable abstract ModelMapper<BusinessTransactionTypeModel, BusinessTransactionType> businessTransactionTypeModelMapper(BusinessTransactionTypeModelMapper businessTransactionTypeModelMapper);