-
Notifications
You must be signed in to change notification settings - Fork 5.3k
/
MapOptions.java
138 lines (123 loc) · 3.48 KB
/
MapOptions.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
/**
* Copyright 2016 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson.api;
import org.redisson.api.map.MapLoader;
import org.redisson.api.map.MapWriter;
/**
* RMap options object.
*
* @author Nikita Koksharov
*
* @param <K> key type
* @param <V> value type
*/
public class MapOptions<K, V> {
public enum WriteMode {
/**
* In write behind mode all data written in map object
* also written using MapWriter in asynchronous mode.
*/
WRITE_BEHIND,
/**
* In write through mode all write operations for map object
* are synchronized with MapWriter write operations.
* If MapWriter throws an error then it will be re-thrown to Map operation caller.
*/
WRITE_THROUGH
}
private MapLoader<K, V> loader;
private MapWriter<K, V> writer;
private WriteMode writeMode = WriteMode.WRITE_THROUGH;
private int writeBehindThreads = 1;
protected MapOptions() {
}
protected MapOptions(MapOptions<K, V> copy) {
}
/**
* Creates a new instance of MapOptions with default options.
* <p>
* This is equivalent to:
* <pre>
* new MapOptions()
* .writer(null, null).loader(null);
* </pre>
*
* @param <K> key type
* @param <V> value type
*
* @return MapOptions instance
*
*/
public static <K, V> MapOptions<K, V> defaults() {
return new MapOptions<K, V>();
}
/**
* Sets {@link MapWriter} object.
*
* @param writer object
* @return MapOptions instance
*/
public MapOptions<K, V> writer(MapWriter<K, V> writer) {
this.writer = writer;
return this;
}
public MapWriter<K, V> getWriter() {
return writer;
}
/**
* Sets threads amount used in write behind mode.
* <p>
* Default is <code>1</code>
*
* @param writeBehindThreads - threads amount
* @return MapOptions instance
*/
public MapOptions<K, V> writeBehindThreads(int writeBehindThreads) {
this.writeBehindThreads = writeBehindThreads;
return this;
}
public int getWriteBehindThreads() {
return writeBehindThreads;
}
/**
* Sets write mode.
* <p>
* Default is <code>{@link WriteMode#WRITE_THROUGH}</code>
*
* @param writeMode - write mode
* @return MapOptions instance
*/
public MapOptions<K, V> writeMode(WriteMode writeMode) {
this.writeMode = writeMode;
return this;
}
public WriteMode getWriteMode() {
return writeMode;
}
/**
* Sets {@link MapLoader} object.
*
* @param loader object
* @return MapOptions instance
*/
public MapOptions<K, V> loader(MapLoader<K, V> loader) {
this.loader = loader;
return this;
}
public MapLoader<K, V> getLoader() {
return loader;
}
}