/
DefaultColumnFieldValue.java
112 lines (94 loc) · 3.86 KB
/
DefaultColumnFieldValue.java
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
/*
* Copyright (c) 2022 Contributors to the Eclipse Foundation
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Apache License v2.0 which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php.
*
* You may elect to redistribute this code under either of these licenses.
*
* Contributors:
*
* Otavio Santana
*/
package org.eclipse.jnosql.mapping.column;
import org.eclipse.jnosql.mapping.AttributeConverter;
import org.eclipse.jnosql.communication.column.Column;
import org.eclipse.jnosql.mapping.core.Converters;
import org.eclipse.jnosql.mapping.metadata.FieldMetadata;
import org.eclipse.jnosql.mapping.metadata.MappingType;
import org.eclipse.jnosql.mapping.metadata.FieldValue;
import org.eclipse.jnosql.mapping.metadata.DefaultFieldValue;
import org.eclipse.jnosql.mapping.metadata.GenericFieldMetadata;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import static org.eclipse.jnosql.mapping.metadata.MappingType.COLLECTION;
import static org.eclipse.jnosql.mapping.metadata.MappingType.EMBEDDED;
import static org.eclipse.jnosql.mapping.metadata.MappingType.ENTITY;
import static java.util.Collections.singletonList;
final class DefaultColumnFieldValue implements ColumnFieldValue {
private final FieldValue fieldValue;
private DefaultColumnFieldValue(FieldValue fieldValue) {
this.fieldValue = fieldValue;
}
@Override
public Object value() {
return fieldValue.value();
}
@Override
public FieldMetadata field() {
return fieldValue.field();
}
@Override
public boolean isNotEmpty() {
return fieldValue.isNotEmpty();
}
@SuppressWarnings("unchecked")
@Override
public <X, Y> List<Column> toColumn(ColumnEntityConverter converter, Converters converters) {
if (value() == null) {
return singletonList(Column.of(getName(), null));
} else if (EMBEDDED.equals(getType())) {
return converter.toColumn(value()).columns();
} else if (ENTITY.equals(getType())) {
return singletonList(Column.of(getName(), converter.toColumn(value()).columns()));
} else if (isEmbeddableCollection()) {
return singletonList(Column.of(getName(), getColumns(converter)));
}
Optional<Class<AttributeConverter<Object, Object>>> optionalConverter = field().converter();
if (optionalConverter.isPresent()) {
AttributeConverter<X, Y> attributeConverter = converters.get(field());
return singletonList(Column.of(getName(), attributeConverter.convertToDatabaseColumn((X) value())));
}
return singletonList(Column.of(getName(), value()));
}
private List<List<Column>> getColumns(ColumnEntityConverter converter) {
List<List<Column>> columns = new ArrayList<>();
for (Object element : (Iterable) value()) {
columns.add(converter.toColumn(element).columns());
}
return columns;
}
private boolean isEmbeddableCollection() {
return COLLECTION.equals(getType()) && isEmbeddableElement();
}
private MappingType getType() {
return field().mappingType();
}
private String getName() {
return field().name();
}
private boolean isEmbeddableElement() {
return ((GenericFieldMetadata) field()).isEmbeddable();
}
@Override
public String toString() {
return "ColumnFieldValue{" + "fieldValue=" + fieldValue +
'}';
}
static ColumnFieldValue of(Object value, FieldMetadata field) {
return new DefaultColumnFieldValue(new DefaultFieldValue(value, field));
}
}