Function bodies 391 total

  public String slug() {
    return slug;
  }

  public List<ModelRelation> relations() {
    return Collections.unmodifiableList(relations);
  }

  private static String requireNonBlank(String v, String field) {
    if (v == null || v.isBlank())
      throw new IllegalArgumentException(field + " must not be blank");
    return v.strip();
  }

  private static String slugify(String name) {
    return name.strip().toLowerCase().replaceAll("[^a-z0-9]+", "-");
  }

public record ModelId(UUID value) {
  public ModelId {
    Objects.requireNonNull(value, "ModelId value must not be null");
  }

  public static ModelId generate() {
    return new ModelId(UUID.randomUUID());
  }

  public static ModelId of(String value) {
    return new ModelId(UUID.fromString(value));
  }
}

public record ModelId(UUID value) {
  public ModelId {
    Objects.requireNonNull(value, "ModelId value must not be null");
  }

  public static ModelId generate() {
    return new ModelId(UUID.randomUUID());
  }

  public static ModelId of(String value) {
    return new ModelId(UUID.fromString(value));
  }
}

  public static ModelId generate() {
    return new ModelId(UUID.randomUUID());
  }

  public static ModelId of(String value) {
    return new ModelId(UUID.fromString(value));
  }

public class ModelRelation {

  private final ModelId targetModelId;
  private final Type type;
  private final String note;

  public ModelRelation(ModelId targetModelId, Type type, String note) {
    this.targetModelId = Objects.requireNonNull(targetModelId);
    this.type = Objects.requireNonNull(type);
    this.note = note;
  }

  public ModelId targetModelId() {
    return targetModelId;
  }

  public Type type() {
    return type;
  }

  public String note() {
    return note;
  }

  public enum Type {SUCCESSOR, PREDECESSOR, REBADGE, PLATFORM_SIBLING}
}

  public ModelRelation(ModelId targetModelId, Type type, String note) {
    this.targetModelId = Objects.requireNonNull(targetModelId);
    this.type = Objects.requireNonNull(type);
    this.note = note;
  }

  public ModelId targetModelId() {
    return targetModelId;
  }

  public Type type() {
    return type;
  }

  public String note() {
    return note;
  }

public record YearRange(int from, Integer to) {

  public YearRange {
    if (from < 1886) throw new IllegalArgumentException("No cars before 1886");
    if (to != null && to < from) throw new IllegalArgumentException("'to' must be >= 'from'");
  }

  public boolean isCurrent() {
    return to == null;
  }

  public boolean overlaps(YearRange other) {
    int otherTo = other.to() != null ? other.to() : Integer.MAX_VALUE;
    int thisTo = this.to != null ? this.to : Integer.MAX_VALUE;
    return this.from <= otherTo && other.from() <= thisTo;
  }
}

public record YearRange(int from, Integer to) {

  public YearRange {
    if (from < 1886) throw new IllegalArgumentException("No cars before 1886");
    if (to != null && to < from) throw new IllegalArgumentException("'to' must be >= 'from'");
  }

  public boolean isCurrent() {
    return to == null;
  }

  public boolean overlaps(YearRange other) {
    int otherTo = other.to() != null ? other.to() : Integer.MAX_VALUE;
    int thisTo = this.to != null ? this.to : Integer.MAX_VALUE;
    return this.from <= otherTo && other.from() <= thisTo;
  }
}

  public boolean isCurrent() {
    return to == null;
  }

  public boolean overlaps(YearRange other) {
    int otherTo = other.to() != null ? other.to() : Integer.MAX_VALUE;
    int thisTo = this.to != null ? this.to : Integer.MAX_VALUE;
    return this.from <= otherTo && other.from() <= thisTo;
  }

public record TransmissionId(UUID value) {
  public TransmissionId {
    Objects.requireNonNull(value, "TransmissionId value must not be null");
  }

  public static TransmissionId generate() {
    return new TransmissionId(UUID.randomUUID());
  }

  public static TransmissionId of(String value) {
    return new TransmissionId(UUID.fromString(value));
  }
}

public record TransmissionId(UUID value) {
  public TransmissionId {
    Objects.requireNonNull(value, "TransmissionId value must not be null");
  }

  public static TransmissionId generate() {
    return new TransmissionId(UUID.randomUUID());
  }

  public static TransmissionId of(String value) {
    return new TransmissionId(UUID.fromString(value));
  }
}

  public static TransmissionId generate() {
    return new TransmissionId(UUID.randomUUID());
  }

  public static TransmissionId of(String value) {
    return new TransmissionId(UUID.fromString(value));
  }

public class Transmission {

  private TransmissionId id;
  private TransmissionType type;
  private int gearCount;

  private Transmission() {
  }

  public static Transmission create(TransmissionType type, int gearCount) {
    if (gearCount < 1 || gearCount > 12)
      throw new IllegalArgumentException("Unexpected gear count: " + gearCount);
    var t = new Transmission();
    t.id = TransmissionId.generate();
    t.type = Objects.requireNonNull(type);
    t.gearCount = gearCount;
    return t;
  }

  public static Transmission reconstitute(TransmissionId id, TransmissionType type, int gearCount) {
    var t = new Transmission();
    t.id = id;
    t.type = type;
    t.gearCount = gearCount;
    return t;
  }

  public TransmissionId id() {
    return id;
  }

  public TransmissionType type() {
    return type;
  }

  public int gearCount() {
    return gearCount;
  }
}

  public static Transmission create(TransmissionType type, int gearCount) {
    if (gearCount < 1 || gearCount > 12)
      throw new IllegalArgumentException("Unexpected gear count: " + gearCount);
    var t = new Transmission();
    t.id = TransmissionId.generate();
    t.type = Objects.requireNonNull(type);
    t.gearCount = gearCount;
    return t;
  }

  public static Transmission reconstitute(TransmissionId id, TransmissionType type, int gearCount) {
    var t = new Transmission();
    t.id = id;
    t.type = type;
    t.gearCount = gearCount;
    return t;
  }

  public TransmissionId id() {
    return id;
  }

  public TransmissionType type() {
    return type;
  }

  public int gearCount() {
    return gearCount;
  }

public record VariantId(UUID value) {
  public VariantId {
    Objects.requireNonNull(value, "VariantId value must not be null");
  }

  public static VariantId generate() {
    return new VariantId(UUID.randomUUID());
  }

  public static VariantId of(String value) {
    return new VariantId(UUID.fromString(value));
  }
}

public record VariantId(UUID value) {
  public VariantId {
    Objects.requireNonNull(value, "VariantId value must not be null");
  }

  public static VariantId generate() {
    return new VariantId(UUID.randomUUID());
  }

  public static VariantId of(String value) {
    return new VariantId(UUID.fromString(value));
  }
}

  public static VariantId generate() {
    return new VariantId(UUID.randomUUID());
  }

  public static VariantId of(String value) {
    return new VariantId(UUID.fromString(value));
  }

public class Variant {

  private VariantId id;
  private BodyId bodyId;
  private Set<EngineId> engineIds = new LinkedHashSet<>();
  private TransmissionId transmissionId;
  private Drivetrain drivetrain;
  private Integer groundClearanceMm;
  private int curbWeightKg;
  private Integer systemPowerKw;
  private Set<String> markets = new LinkedHashSet<>();

  private Variant() {
  }

  public static Variant create(BodyId bodyId, TransmissionId transmissionId,
                               Drivetrain drivetrain, int curbWeightKg) {
    if (curbWeightKg <= 0) throw new IllegalArgumentException("curbWeightKg must be > 0");
    var v = new Variant();
    v.id = VariantId.generate();
    v.bodyId = Objects.requireNonNull(bodyId, "bodyId must not be null");
    v.transmissionId = Objects.requireNonNull(transmissionId, "transmissionId must not be null");
    v.drivetrain = Objects.requireNonNull(drivetrain, "drivetrain must not be null");
    v.curbWeightKg = curbWeightKg;
    return v;
  }

  public static Variant create(BodyId bodyId, TransmissionId transmissionId,
                               Drivetrain drivetrain, int curbWeightKg) {
    if (curbWeightKg <= 0) throw new IllegalArgumentException("curbWeightKg must be > 0");
    var v = new Variant();
    v.id = VariantId.generate();
    v.bodyId = Objects.requireNonNull(bodyId, "bodyId must not be null");
    v.transmissionId = Objects.requireNonNull(transmissionId, "transmissionId must not be null");
    v.drivetrain = Objects.requireNonNull(drivetrain, "drivetrain must not be null");
    v.curbWeightKg = curbWeightKg;
    return v;
  }

  public static Variant reconstitute(VariantId id, BodyId bodyId,
                                     Set<EngineId> engineIds,
                                     TransmissionId transmissionId,
                                     Drivetrain drivetrain,
                                     Integer groundClearanceMm,
                                     int curbWeightKg,
                                     Integer systemPowerKw,
                                     Set<String> markets) {
    var v = new Variant();
    v.id = id;
    v.bodyId = bodyId;
    v.engineIds = new LinkedHashSet<>(engineIds);
    v.transmissionId = transmissionId;
    v.drivetrain = drivetrain;
    v.groundClearanceMm = groundClearanceMm;
    v.curbWeightKg = curbWeightKg;
    v.systemPowerKw = systemPowerKw;
    v.markets = new LinkedHashSet<>(markets);
    return v;
  }

  public void addEngine(EngineId engineId) {
    engineIds.add(Objects.requireNonNull(engineId, "engineId must not be null"));
  }

  public void addMarket(String market) {
    if (market == null || market.isBlank())
      throw new IllegalArgumentException("market must not be blank");
    markets.add(market.toUpperCase().strip());
  }

  public void setGroundClearanceMm(int groundClearanceMm) {
    if (groundClearanceMm <= 0)
      throw new IllegalArgumentException("groundClearanceMm must be > 0");
    this.groundClearanceMm = groundClearanceMm;
  }

  public void setSystemPowerKw(int systemPowerKw) {
    if (systemPowerKw <= 0)
      throw new IllegalArgumentException("systemPowerKw must be > 0");
    this.systemPowerKw = systemPowerKw;
  }

  public VariantId id() {
    return id;
  }

  public BodyId bodyId() {
    return bodyId;
  }

  public Set<EngineId> engineIds() {
    return Collections.unmodifiableSet(engineIds);
  }

  public TransmissionId transmissionId() {
    return transmissionId;
  }

  public Drivetrain drivetrain() {
    return drivetrain;
  }

  public Integer groundClearanceMm() {
    return groundClearanceMm;
  }

  public int curbWeightKg() {
    return curbWeightKg;
  }

  public Integer systemPowerKw() {
    return systemPowerKw;
  }

  public Set<String> markets() {
    return Collections.unmodifiableSet(markets);
  }

public class ApplicationConfig {

  @Bean
  public MakeService makeService(MakeRepository makeRepository) {
    return new MakeService(makeRepository);
  }

  @Bean
  public CarModelService carModelService(CarModelRepository modelRepository,
                                         MakeRepository makeRepository) {
    return new CarModelService(modelRepository, makeRepository);
  }

  @Bean
  public EngineService engineService(EngineRepository engineRepository) {
    return new EngineService(engineRepository);
  }

  @Bean
  public TransmissionService transmissionService(TransmissionRepository transmissionRepository) {
    return new TransmissionService(transmissionRepository);
  }

  @Bean
  public GenerationService generationService(GenerationRepository generationRepository,
                                             CarModelRepository modelRepository) {
    return new GenerationService(generationRepository, modelRepository);
  }

  @Bean
  public BodyService bodyService(BodyReposi

  public MakeService makeService(MakeRepository makeRepository) {
    return new MakeService(makeRepository);
  }

  public CarModelService carModelService(CarModelRepository modelRepository,
                                         MakeRepository makeRepository) {
    return new CarModelService(modelRepository, makeRepository);
  }