Spring JPA値オブジェクト設計 - @Embeddableで複合型を表現する

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// プリミティブ型のみの設計（アンチパターン）
@Entity
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 住所情報がバラバラに散らばっている
    private String streetAddress;
    private String city;
    private String state;
    private String postalCode;
    private String country;

    // 金額情報も同様
    private BigDecimal creditLimitAmount;
    private String creditLimitCurrency;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

import jakarta.persistence.Embeddable;

@Embeddable
public class Address {

    private String streetAddress;
    private String city;
    private String state;
    private String postalCode;
    private String country;

    // JPAが必要とするデフォルトコンストラクタ
    protected Address() {
    }

    public Address(String streetAddress, String city, String state,
                   String postalCode, String country) {
        this.streetAddress = streetAddress;
        this.city = city;
        this.state = state;
        this.postalCode = postalCode;
        this.country = country;
    }

    // getters（setterは不要 - 不変オブジェクトとして設計）
    public String getStreetAddress() {
        return streetAddress;
    }

    public String getCity() {
        return city;
    }

    public String getState() {
        return state;
    }

    public String getPostalCode() {
        return postalCode;
    }

    public String getCountry() {
        return country;
    }

    // equalsとhashCodeの実装（値オブジェクトの同値性判定に必要）
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Address address = (Address) o;
        return Objects.equals(streetAddress, address.streetAddress)
                && Objects.equals(city, address.city)
                && Objects.equals(state, address.state)
                && Objects.equals(postalCode, address.postalCode)
                && Objects.equals(country, address.country);
    }

    @Override
    public int hashCode() {
        return Objects.hash(streetAddress, city, state, postalCode, country);
    }

    @Override
    public String toString() {
        return String.format("%s, %s, %s %s, %s",
                streetAddress, city, state, postalCode, country);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private String email;

    @Embedded
    private Address address;

    protected Customer() {
    }

    public Customer(String name, String email, Address address) {
        this.name = name;
        this.email = email;
        this.address = address;
    }

    // getters
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }

    public Address getAddress() {
        return address;
    }

    // 住所を変更する場合は新しいAddressオブジェクトで置き換え
    public void changeAddress(Address newAddress) {
        this.address = newAddress;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

CREATE TABLE customer (
    id BIGINT NOT NULL AUTO_INCREMENT,
    name VARCHAR(255),
    email VARCHAR(255),
    street_address VARCHAR(255),
    city VARCHAR(255),
    state VARCHAR(255),
    postal_code VARCHAR(255),
    country VARCHAR(255),
    PRIMARY KEY (id)
);

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;
import java.util.Objects;

@Embeddable
public class Address {

    @Column(name = "street_address", nullable = false, length = 200)
    private String streetAddress;

    @Column(name = "city", nullable = false, length = 100)
    private String city;

    @Column(name = "state", length = 100)
    private String state;

    @Column(name = "postal_code", nullable = false, length = 20)
    private String postalCode;

    @Column(name = "country", nullable = false, length = 2)
    private String countryCode;

    protected Address() {
    }

    private Address(String streetAddress, String city, String state,
                    String postalCode, String countryCode) {
        this.streetAddress = streetAddress;
        this.city = city;
        this.state = state;
        this.postalCode = postalCode;
        this.countryCode = countryCode;
    }

    // ファクトリメソッドでバリデーションを実施
    public static Address of(String streetAddress, String city, String state,
                             String postalCode, String countryCode) {
        validateStreetAddress(streetAddress);
        validateCity(city);
        validatePostalCode(postalCode);
        validateCountryCode(countryCode);
        return new Address(streetAddress, city, state, postalCode, countryCode);
    }

    // 日本の住所用ファクトリメソッド
    public static Address ofJapan(String postalCode, String prefecture,
                                  String city, String streetAddress) {
        return of(streetAddress, city, prefecture, postalCode, "JP");
    }

    private static void validateStreetAddress(String streetAddress) {
        if (streetAddress == null || streetAddress.isBlank()) {
            throw new IllegalArgumentException("Street address cannot be empty");
        }
        if (streetAddress.length() > 200) {
            throw new IllegalArgumentException(
                    "Street address cannot exceed 200 characters");
        }
    }

    private static void validateCity(String city) {
        if (city == null || city.isBlank()) {
            throw new IllegalArgumentException("City cannot be empty");
        }
    }

    private static void validatePostalCode(String postalCode) {
        if (postalCode == null || postalCode.isBlank()) {
            throw new IllegalArgumentException("Postal code cannot be empty");
        }
    }

    private static void validateCountryCode(String countryCode) {
        if (countryCode == null || countryCode.length() != 2) {
            throw new IllegalArgumentException(
                    "Country code must be a 2-letter ISO code");
        }
    }

    // getters
    public String getStreetAddress() {
        return streetAddress;
    }

    public String getCity() {
        return city;
    }

    public String getState() {
        return state;
    }

    public String getPostalCode() {
        return postalCode;
    }

    public String getCountryCode() {
        return countryCode;
    }

    public boolean isJapan() {
        return "JP".equals(countryCode);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Address address = (Address) o;
        return Objects.equals(streetAddress, address.streetAddress)
                && Objects.equals(city, address.city)
                && Objects.equals(state, address.state)
                && Objects.equals(postalCode, address.postalCode)
                && Objects.equals(countryCode, address.countryCode);
    }

    @Override
    public int hashCode() {
        return Objects.hash(streetAddress, city, state, postalCode, countryCode);
    }

    @Override
    public String toString() {
        if (isJapan()) {
            return String.format("〒%s %s %s %s",
                    postalCode, state, city, streetAddress);
        }
        return String.format("%s, %s, %s %s, %s",
                streetAddress, city, state, postalCode, countryCode);
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Currency;
import java.util.Objects;

@Embeddable
public class Money {

    @Column(name = "amount", nullable = false, precision = 19, scale = 4)
    private BigDecimal amount;

    @Column(name = "currency", nullable = false, length = 3)
    private String currencyCode;

    protected Money() {
    }

    private Money(BigDecimal amount, String currencyCode) {
        this.amount = amount;
        this.currencyCode = currencyCode;
    }

    public static Money of(BigDecimal amount, String currencyCode) {
        validateAmount(amount);
        validateCurrencyCode(currencyCode);

        Currency currency = Currency.getInstance(currencyCode);
        BigDecimal normalizedAmount = amount.setScale(
                currency.getDefaultFractionDigits(),
                RoundingMode.HALF_UP
        );
        return new Money(normalizedAmount, currencyCode);
    }

    public static Money of(String amount, String currencyCode) {
        return of(new BigDecimal(amount), currencyCode);
    }

    public static Money yen(BigDecimal amount) {
        return of(amount.setScale(0, RoundingMode.HALF_UP), "JPY");
    }

    public static Money yen(long amount) {
        return yen(BigDecimal.valueOf(amount));
    }

    public static Money usd(BigDecimal amount) {
        return of(amount, "USD");
    }

    public static Money zero(String currencyCode) {
        return of(BigDecimal.ZERO, currencyCode);
    }

    private static void validateAmount(BigDecimal amount) {
        if (amount == null) {
            throw new IllegalArgumentException("Amount cannot be null");
        }
    }

    private static void validateCurrencyCode(String currencyCode) {
        if (currencyCode == null || currencyCode.length() != 3) {
            throw new IllegalArgumentException(
                    "Currency code must be a 3-letter ISO code");
        }
        try {
            Currency.getInstance(currencyCode);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException(
                    "Invalid currency code: " + currencyCode);
        }
    }

    // 加算
    public Money add(Money other) {
        requireSameCurrency(other);
        return new Money(this.amount.add(other.amount), this.currencyCode);
    }

    // 減算
    public Money subtract(Money other) {
        requireSameCurrency(other);
        return new Money(this.amount.subtract(other.amount), this.currencyCode);
    }

    // 乗算
    public Money multiply(BigDecimal multiplier) {
        BigDecimal newAmount = this.amount.multiply(multiplier)
                .setScale(getCurrency().getDefaultFractionDigits(),
                        RoundingMode.HALF_UP);
        return new Money(newAmount, this.currencyCode);
    }

    public Money multiply(int multiplier) {
        return multiply(BigDecimal.valueOf(multiplier));
    }

    // 割合を適用（税率計算など）
    public Money applyRate(BigDecimal rate) {
        return multiply(rate.add(BigDecimal.ONE));
    }

    private void requireSameCurrency(Money other) {
        if (!this.currencyCode.equals(other.currencyCode)) {
            throw new IllegalArgumentException(
                    String.format("Currency mismatch: %s vs %s",
                            this.currencyCode, other.currencyCode));
        }
    }

    // getters
    public BigDecimal getAmount() {
        return amount;
    }

    public String getCurrencyCode() {
        return currencyCode;
    }

    public Currency getCurrency() {
        return Currency.getInstance(currencyCode);
    }

    public boolean isPositive() {
        return amount.compareTo(BigDecimal.ZERO) > 0;
    }

    public boolean isNegative() {
        return amount.compareTo(BigDecimal.ZERO) < 0;
    }

    public boolean isZero() {
        return amount.compareTo(BigDecimal.ZERO) == 0;
    }

    public boolean isGreaterThan(Money other) {
        requireSameCurrency(other);
        return this.amount.compareTo(other.amount) > 0;
    }

    public boolean isLessThan(Money other) {
        requireSameCurrency(other);
        return this.amount.compareTo(other.amount) < 0;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Money money = (Money) o;
        return amount.compareTo(money.amount) == 0
                && Objects.equals(currencyCode, money.currencyCode);
    }

    @Override
    public int hashCode() {
        return Objects.hash(amount.stripTrailingZeros(), currencyCode);
    }

    @Override
    public String toString() {
        Currency currency = getCurrency();
        return String.format("%s %s",
                currency.getSymbol(),
                amount.setScale(currency.getDefaultFractionDigits(),
                        RoundingMode.HALF_UP));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.Objects;

@Embeddable
public class DateRange {

    @Column(name = "start_date", nullable = false)
    private LocalDate startDate;

    @Column(name = "end_date", nullable = false)
    private LocalDate endDate;

    protected DateRange() {
    }

    private DateRange(LocalDate startDate, LocalDate endDate) {
        this.startDate = startDate;
        this.endDate = endDate;
    }

    public static DateRange of(LocalDate startDate, LocalDate endDate) {
        if (startDate == null || endDate == null) {
            throw new IllegalArgumentException("Dates cannot be null");
        }
        if (startDate.isAfter(endDate)) {
            throw new IllegalArgumentException(
                    "Start date must be before or equal to end date");
        }
        return new DateRange(startDate, endDate);
    }

    public static DateRange ofDays(LocalDate startDate, int days) {
        if (days < 0) {
            throw new IllegalArgumentException("Days must be non-negative");
        }
        return of(startDate, startDate.plusDays(days));
    }

    public static DateRange ofCurrentMonth() {
        LocalDate now = LocalDate.now();
        return of(now.withDayOfMonth(1),
                now.withDayOfMonth(now.lengthOfMonth()));
    }

    // getters
    public LocalDate getStartDate() {
        return startDate;
    }

    public LocalDate getEndDate() {
        return endDate;
    }

    public long getDays() {
        return ChronoUnit.DAYS.between(startDate, endDate) + 1;
    }

    public boolean contains(LocalDate date) {
        return !date.isBefore(startDate) && !date.isAfter(endDate);
    }

    public boolean overlaps(DateRange other) {
        return !this.endDate.isBefore(other.startDate)
                && !this.startDate.isAfter(other.endDate);
    }

    public boolean isActive() {
        return contains(LocalDate.now());
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        DateRange dateRange = (DateRange) o;
        return Objects.equals(startDate, dateRange.startDate)
                && Objects.equals(endDate, dateRange.endDate);
    }

    @Override
    public int hashCode() {
        return Objects.hash(startDate, endDate);
    }

    @Override
    public String toString() {
        return String.format("%s ~ %s", startDate, endDate);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import jakarta.persistence.AttributeOverride;
import jakarta.persistence.AttributeOverrides;
import jakarta.persistence.Column;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Company {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @Embedded
    @AttributeOverrides({
        @AttributeOverride(
            name = "streetAddress",
            column = @Column(name = "hq_street", length = 200)
        ),
        @AttributeOverride(
            name = "city",
            column = @Column(name = "hq_city", length = 100)
        ),
        @AttributeOverride(
            name = "state",
            column = @Column(name = "hq_state", length = 100)
        ),
        @AttributeOverride(
            name = "postalCode",
            column = @Column(name = "hq_postal_code", length = 20)
        ),
        @AttributeOverride(
            name = "countryCode",
            column = @Column(name = "hq_country", length = 2)
        )
    })
    private Address headquarters;

    // constructors, getters, setters...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

CREATE TABLE company (
    id BIGINT NOT NULL AUTO_INCREMENT,
    name VARCHAR(255),
    hq_street VARCHAR(200),
    hq_city VARCHAR(100),
    hq_state VARCHAR(100),
    hq_postal_code VARCHAR(20),
    hq_country VARCHAR(2),
    PRIMARY KEY (id)
);

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109

@Entity
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String orderNumber;

    @Embedded
    @AttributeOverrides({
        @AttributeOverride(
            name = "streetAddress",
            column = @Column(name = "shipping_street")
        ),
        @AttributeOverride(
            name = "city",
            column = @Column(name = "shipping_city")
        ),
        @AttributeOverride(
            name = "state",
            column = @Column(name = "shipping_state")
        ),
        @AttributeOverride(
            name = "postalCode",
            column = @Column(name = "shipping_postal_code")
        ),
        @AttributeOverride(
            name = "countryCode",
            column = @Column(name = "shipping_country")
        )
    })
    private Address shippingAddress;

    @Embedded
    @AttributeOverrides({
        @AttributeOverride(
            name = "streetAddress",
            column = @Column(name = "billing_street")
        ),
        @AttributeOverride(
            name = "city",
            column = @Column(name = "billing_city")
        ),
        @AttributeOverride(
            name = "state",
            column = @Column(name = "billing_state")
        ),
        @AttributeOverride(
            name = "postalCode",
            column = @Column(name = "billing_postal_code")
        ),
        @AttributeOverride(
            name = "countryCode",
            column = @Column(name = "billing_country")
        )
    })
    private Address billingAddress;

    @Embedded
    @AttributeOverrides({
        @AttributeOverride(
            name = "amount",
            column = @Column(name = "total_amount")
        ),
        @AttributeOverride(
            name = "currencyCode",
            column = @Column(name = "total_currency")
        )
    })
    private Money totalPrice;

    protected Order() {
    }

    public Order(String orderNumber, Address shippingAddress,
                 Address billingAddress, Money totalPrice) {
        this.orderNumber = orderNumber;
        this.shippingAddress = shippingAddress;
        this.billingAddress = billingAddress;
        this.totalPrice = totalPrice;
    }

    // getters...
    public Long getId() {
        return id;
    }

    public String getOrderNumber() {
        return orderNumber;
    }

    public Address getShippingAddress() {
        return shippingAddress;
    }

    public Address getBillingAddress() {
        return billingAddress;
    }

    public Money getTotalPrice() {
        return totalPrice;
    }

    // 配送先と請求先が同じかどうかを判定
    public boolean hasSameShippingAndBillingAddress() {
        return Objects.equals(shippingAddress, billingAddress);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

CREATE TABLE orders (
    id BIGINT NOT NULL AUTO_INCREMENT,
    order_number VARCHAR(255),
    shipping_street VARCHAR(255),
    shipping_city VARCHAR(255),
    shipping_state VARCHAR(255),
    shipping_postal_code VARCHAR(255),
    shipping_country VARCHAR(255),
    billing_street VARCHAR(255),
    billing_city VARCHAR(255),
    billing_state VARCHAR(255),
    billing_postal_code VARCHAR(255),
    billing_country VARCHAR(255),
    total_amount DECIMAL(19, 4),
    total_currency VARCHAR(3),
    PRIMARY KEY (id)
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import java.util.Objects;

@Embeddable
public class PhoneNumber {

    public enum PhoneType {
        HOME, WORK, MOBILE, FAX
    }

    @Column(name = "phone_number", nullable = false, length = 20)
    private String number;

    @Enumerated(EnumType.STRING)
    @Column(name = "phone_type", nullable = false, length = 10)
    private PhoneType type;

    protected PhoneNumber() {
    }

    private PhoneNumber(String number, PhoneType type) {
        this.number = number;
        this.type = type;
    }

    public static PhoneNumber of(String number, PhoneType type) {
        if (number == null || number.isBlank()) {
            throw new IllegalArgumentException("Phone number cannot be empty");
        }
        if (type == null) {
            throw new IllegalArgumentException("Phone type cannot be null");
        }
        // 数字、ハイフン、括弧、プラス記号のみを許可
        if (!number.matches("^[\\d\\-\\(\\)\\+\\s]+$")) {
            throw new IllegalArgumentException("Invalid phone number format");
        }
        return new PhoneNumber(normalizeNumber(number), type);
    }

    public static PhoneNumber mobile(String number) {
        return of(number, PhoneType.MOBILE);
    }

    public static PhoneNumber work(String number) {
        return of(number, PhoneType.WORK);
    }

    private static String normalizeNumber(String number) {
        return number.replaceAll("[\\s\\-\\(\\)]", "");
    }

    public String getNumber() {
        return number;
    }

    public PhoneType getType() {
        return type;
    }

    public boolean isMobile() {
        return type == PhoneType.MOBILE;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PhoneNumber that = (PhoneNumber) o;
        return Objects.equals(number, that.number) && type == that.type;
    }

    @Override
    public int hashCode() {
        return Objects.hash(number, type);
    }

    @Override
    public String toString() {
        return String.format("%s (%s)", number, type);
    }
}