/
MessageMapperRegistry.java
152 lines (120 loc) · 4.23 KB
/
MessageMapperRegistry.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
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
/*
* Copyright (c) 2017 Bosch Software Innovations GmbH.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/org/documents/epl-2.0/index.php
*
* Contributors:
* Bosch Software Innovations GmbH - initial contribution
*/
package org.eclipse.ditto.services.amqpbridge.mapping.mapper;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import javax.annotation.Nullable;
import org.eclipse.ditto.model.amqpbridge.InternalMessage;
import org.eclipse.ditto.protocoladapter.Adaptable;
import com.google.common.base.Converter;
/**
* A registry for instantiated mappers.
*/
public class MessageMapperRegistry implements Collection<MessageMapper> {
private final Map<String, MessageMapper> registry;
@Nullable
private MessageMapper defaultMapper;
private MessageMapperRegistry(@Nullable final MessageMapper defaultMapper) {
registry = new HashMap<>();
setDefaultMapper(defaultMapper);
}
MessageMapperRegistry(@Nullable final MessageMapper defaultMapper, final List<MessageMapper> mappers) {
this(defaultMapper);
addAll(mappers);
}
@Nullable
public MessageMapper getDefaultMapper() {
return defaultMapper;
}
private void setDefaultMapper(@Nullable final MessageMapper defaultMapper) {
this.defaultMapper = defaultMapper;
}
public Optional<MessageMapper> findMapper(final InternalMessage message) {
return MessageMapper.findContentType(message).map(registry::get);
}
public Optional<MessageMapper> selectMapper(final InternalMessage message) {
Optional<MessageMapper> mapper = findMapper(message);
return mapper.isPresent() ? mapper : Optional.ofNullable(getDefaultMapper());
}
private Optional<Converter<Adaptable, InternalMessage>> findMapper(final Adaptable adaptable) {
return MessageMapper.findContentType(adaptable).map(registry::get).map(MessageMapper::reverse);
}
public Optional<Converter<Adaptable, InternalMessage>> selectMapper(final Adaptable adaptable) {
Optional<Converter<Adaptable, InternalMessage>> mapper = findMapper(adaptable);
return mapper.isPresent() ? mapper : Optional.ofNullable(getDefaultMapper()).map(MessageMapper::reverse);
}
@Override
public int size() {
return registry.size();
}
@Override
public boolean isEmpty() {
return registry.isEmpty();
}
@Override
public boolean contains(final Object o) {
return registry.values().contains(o);
}
@Override
public Iterator<MessageMapper> iterator() {
return registry.values().iterator();
}
@Override
public Object[] toArray() {
return registry.values().toArray();
}
@Override
public <T> T[] toArray(final T[] a) {
//noinspection SuspiciousToArrayCall
return registry.values().toArray(a);
}
@Override
public boolean add(final MessageMapper messageMapper) {
return !messageMapper.equals(registry.put(messageMapper.getContentType(), messageMapper));
}
@Override
public boolean remove(final Object o) {
return !MessageMapper.class.isAssignableFrom(o.getClass()) &&
Objects.nonNull(registry.remove(((MessageMapper) o).getContentType()));
}
@Override
public boolean containsAll(final Collection<?> c) {
return registry.values().containsAll(c);
}
@Override
public boolean addAll(final Collection<? extends MessageMapper> c) {
boolean[] changed = new boolean[1];
c.forEach(e -> {
if (this.add(e)) {
changed[0] = true;
}
});
return changed[0];
}
@Override
public boolean removeAll(final Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean retainAll(final Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public void clear() {
registry.clear();
}
}