#2187

Committed 07 Jun 2025 09:11AM UTC coverage: 69.535% (-0.5%) from 69.989%

Build # #2187

Build Type

push

Committed by

Commit Message

redis-8.0

Run Details

1 of 123 new or added lines in 13 files covered. (0.81%)

1 existing line in 1 file now uncovered.

6642 of 9552 relevant lines covered (69.54%)

0.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.37

/src/main/java/com/moilioncircle/redis/replicator/rdb/datatype/KeyValuePairs.java

/*
 * Copyright 2016-2017 Leon Chen
 *
 * 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 com.moilioncircle.redis.replicator.rdb.datatype;

import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueTTLHash;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueHash;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueList;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueModule;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueSet;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueStream;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueString;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueZSet;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyValuePair;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueByteArrayIterator;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueTTLMapEntryIterator;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueMapEntryIterator;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueZSetEntryIterator;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author Leon Chen
 * @since 3.1.0
 */
public class KeyValuePairs {

    /*
     * Base
     */
    public static KeyValuePair<byte[], byte[]> string(KeyValuePair<byte[], ?> raw, byte[] value) {
        KeyStringValueString kv = new KeyStringValueString();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }

    public static KeyValuePair<byte[], Module> module(KeyValuePair<byte[], ?> raw, Module value) {
        KeyStringValueModule kv = new KeyStringValueModule();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }

    public static KeyValuePair<byte[], Map<byte[], byte[]>> hash(KeyValuePair<byte[], ?> raw, Map<byte[], byte[]> value) {
        KeyStringValueHash kv = new KeyStringValueHash();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }
    
    public static KeyValuePair<byte[], Map<byte[], TTLValue>> ttlHash(KeyValuePair<byte[], ?> raw, Map<byte[], TTLValue> value) {
        KeyStringValueTTLHash kv = new KeyStringValueTTLHash();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }

    public static KeyValuePair<byte[], List<byte[]>> list(KeyValuePair<byte[], ?> raw, List<byte[]> value) {
        KeyStringValueList kv = new KeyStringValueList();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }

    public static KeyValuePair<byte[], Set<byte[]>> set(KeyValuePair<byte[], ?> raw, Set<byte[]> value) {
        KeyStringValueSet kv = new KeyStringValueSet();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }

    public static KeyValuePair<byte[], Set<ZSetEntry>> zset(KeyValuePair<byte[], ?> raw, Set<ZSetEntry> value) {
        KeyStringValueZSet kv = new KeyStringValueZSet();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }

    public static KeyValuePair<byte[], Stream> stream(KeyValuePair<byte[], ?> raw, Stream value) {
        KeyStringValueStream kv = new KeyStringValueStream();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }

    /*
     * Iterator
     */
    public static KeyStringValueMapEntryIterator iterHash(KeyValuePair<byte[], ?> raw, Iterator<Map.Entry<byte[], byte[]>> value) {
        KeyStringValueMapEntryIterator kv = new KeyStringValueMapEntryIterator();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }
    
    public static KeyStringValueTTLMapEntryIterator iterTTLHash(KeyValuePair<byte[], ?> raw, Iterator<Map.Entry<byte[], TTLValue>> value) {
        KeyStringValueTTLMapEntryIterator kv = new KeyStringValueTTLMapEntryIterator();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }

    public static KeyStringValueByteArrayIterator iterList(KeyValuePair<byte[], ?> raw, Iterator<byte[]> value) {
        KeyStringValueByteArrayIterator kv = new KeyStringValueByteArrayIterator();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }

    public static KeyStringValueByteArrayIterator iterSet(KeyValuePair<byte[], ?> raw, Iterator<byte[]> value) {
        KeyStringValueByteArrayIterator kv = new KeyStringValueByteArrayIterator();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }

    public static KeyStringValueZSetEntryIterator iterZset(KeyValuePair<byte[], ?> raw, Iterator<ZSetEntry> value) {
        KeyStringValueZSetEntryIterator kv = new KeyStringValueZSetEntryIterator();
        copy(raw, kv);
        kv.setValue(value);
        return kv;
    }

    /*
     * Batched
     */
    public static BatchedKeyStringValueString string(KeyValuePair<byte[], ?> raw, byte[] value, int batch, boolean last) {
        BatchedKeyStringValueString kv = new BatchedKeyStringValueString();
        copy(raw, kv, batch, last);
        kv.setValue(value);
        return kv;
    }

    public static BatchedKeyStringValueModule module(KeyValuePair<byte[], ?> raw, Module value, int batch, boolean last) {
        BatchedKeyStringValueModule kv = new BatchedKeyStringValueModule();
        copy(raw, kv, batch, last);
        kv.setValue(value);
        return kv;
    }

    public static BatchedKeyStringValueHash hash(KeyValuePair<byte[], ?> raw, Map<byte[], byte[]> value, int batch, boolean last) {
        BatchedKeyStringValueHash kv = new BatchedKeyStringValueHash();
        copy(raw, kv, batch, last);
        kv.setValue(value);
        return kv;
    }
    
    public static BatchedKeyStringValueTTLHash ttlHash(KeyValuePair<byte[], ?> raw, Map<byte[], TTLValue> value, int batch, boolean last) {
        BatchedKeyStringValueTTLHash kv = new BatchedKeyStringValueTTLHash();
        copy(raw, kv, batch, last);
        kv.setValue(value);
        return kv;
    }

    public static BatchedKeyStringValueList list(KeyValuePair<byte[], ?> raw, List<byte[]> value, int batch, boolean last) {
        BatchedKeyStringValueList kv = new BatchedKeyStringValueList();
        copy(raw, kv, batch, last);
        kv.setValue(value);
        return kv;
    }

    public static BatchedKeyStringValueSet set(KeyValuePair<byte[], ?> raw, Set<byte[]> value, int batch, boolean last) {
        BatchedKeyStringValueSet kv = new BatchedKeyStringValueSet();
        copy(raw, kv, batch, last);
        kv.setValue(value);
        return kv;
    }

    public static BatchedKeyStringValueZSet zset(KeyValuePair<byte[], ?> raw, Set<ZSetEntry> value, int batch, boolean last) {
        BatchedKeyStringValueZSet kv = new BatchedKeyStringValueZSet();
        copy(raw, kv, batch, last);
        kv.setValue(value);
        return kv;
    }

    public static BatchedKeyStringValueStream stream(KeyValuePair<byte[], ?> raw, Stream value, int batch, boolean last) {
        BatchedKeyStringValueStream kv = new BatchedKeyStringValueStream();
        copy(raw, kv, batch, last);
        kv.setValue(value);
        return kv;
    }

    /*
     * Helper
     */
    private static void copy(KeyValuePair<byte[], ?> source, KeyValuePair<byte[], ?> target) {
        target.setContext(source.getContext());
        target.setDb(source.getDb());
        target.setSlot(source.getSlot());
        target.setExpiredType(source.getExpiredType());
        target.setExpiredValue(source.getExpiredValue());
        target.setEvictType(source.getEvictType());
        target.setEvictValue(source.getEvictValue());
        target.setValueRdbType(source.getValueRdbType());
        target.setKey(source.getKey());
    }

    private static void copy(KeyValuePair<byte[], ?> source, BatchedKeyValuePair<byte[], ?> target, int batch, boolean last) {
        target.setContext(source.getContext());
        target.setDb(source.getDb());
        target.setSlot(source.getSlot());
        target.setExpiredType(source.getExpiredType());
        target.setExpiredValue(source.getExpiredValue());
        target.setEvictType(source.getEvictType());
        target.setEvictValue(source.getEvictValue());
        target.setValueRdbType(source.getValueRdbType());
        target.setKey(source.getKey());
        target.setBatch(batch);
        target.setLast(last);
    }
}

1	/*
2	* Copyright 2016-2017 Leon Chen
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	package com.moilioncircle.redis.replicator.rdb.datatype;
18
19	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueTTLHash;
20	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueHash;
21	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueList;
22	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueModule;
23	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueSet;
24	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueStream;
25	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueString;
26	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyStringValueZSet;
27	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.BatchedKeyValuePair;
28	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueByteArrayIterator;
29	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueTTLMapEntryIterator;
30	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueMapEntryIterator;
31	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueZSetEntryIterator;
32
33	import java.util.Iterator;
34	import java.util.List;
35	import java.util.Map;
36	import java.util.Set;
37
38	/**
39	* @author Leon Chen
40	* @since 3.1.0
41	*/
42	public class KeyValuePairs {	×
43
44	/*
45	* Base
46	*/
47	public static KeyValuePair<byte[], byte[]> string(KeyValuePair<byte[], ?> raw, byte[] value) {
48	KeyStringValueString kv = new KeyStringValueString();	1✔
49	copy(raw, kv);	1✔
50	kv.setValue(value);	1✔
51	return kv;	1✔
52	}
53
54	public static KeyValuePair<byte[], Module> module(KeyValuePair<byte[], ?> raw, Module value) {
55	KeyStringValueModule kv = new KeyStringValueModule();	×
56	copy(raw, kv);	×
57	kv.setValue(value);	×
58	return kv;	×
59	}
60
61	public static KeyValuePair<byte[], Map<byte[], byte[]>> hash(KeyValuePair<byte[], ?> raw, Map<byte[], byte[]> value) {
62	KeyStringValueHash kv = new KeyStringValueHash();	1✔
63	copy(raw, kv);	1✔
64	kv.setValue(value);	1✔
65	return kv;	1✔
66	}
67
68	public static KeyValuePair<byte[], Map<byte[], TTLValue>> ttlHash(KeyValuePair<byte[], ?> raw, Map<byte[], TTLValue> value) {
NEW 69	KeyStringValueTTLHash kv = new KeyStringValueTTLHash();	×
70	copy(raw, kv);	×
71	kv.setValue(value);	×
72	return kv;	×
73	}
74
75	public static KeyValuePair<byte[], List<byte[]>> list(KeyValuePair<byte[], ?> raw, List<byte[]> value) {
76	KeyStringValueList kv = new KeyStringValueList();	1✔
77	copy(raw, kv);	1✔
78	kv.setValue(value);	1✔
79	return kv;	1✔
80	}
81
82	public static KeyValuePair<byte[], Set<byte[]>> set(KeyValuePair<byte[], ?> raw, Set<byte[]> value) {
83	KeyStringValueSet kv = new KeyStringValueSet();	1✔
84	copy(raw, kv);	1✔
85	kv.setValue(value);	1✔
86	return kv;	1✔
87	}
88
89	public static KeyValuePair<byte[], Set<ZSetEntry>> zset(KeyValuePair<byte[], ?> raw, Set<ZSetEntry> value) {
90	KeyStringValueZSet kv = new KeyStringValueZSet();	1✔
91	copy(raw, kv);	1✔
92	kv.setValue(value);	1✔
93	return kv;	1✔
94	}
95
96	public static KeyValuePair<byte[], Stream> stream(KeyValuePair<byte[], ?> raw, Stream value) {
97	KeyStringValueStream kv = new KeyStringValueStream();	1✔
98	copy(raw, kv);	1✔
99	kv.setValue(value);	1✔
100	return kv;	1✔
101	}
102
103	/*
104	* Iterator
105	*/
106	public static KeyStringValueMapEntryIterator iterHash(KeyValuePair<byte[], ?> raw, Iterator<Map.Entry<byte[], byte[]>> value) {
107	KeyStringValueMapEntryIterator kv = new KeyStringValueMapEntryIterator();	1✔
108	copy(raw, kv);	1✔
109	kv.setValue(value);	1✔
110	return kv;	1✔
111	}
112
113	public static KeyStringValueTTLMapEntryIterator iterTTLHash(KeyValuePair<byte[], ?> raw, Iterator<Map.Entry<byte[], TTLValue>> value) {
NEW 114	KeyStringValueTTLMapEntryIterator kv = new KeyStringValueTTLMapEntryIterator();	×
115	copy(raw, kv);	×
116	kv.setValue(value);	×
117	return kv;	×
118	}
119
120	public static KeyStringValueByteArrayIterator iterList(KeyValuePair<byte[], ?> raw, Iterator<byte[]> value) {
121	KeyStringValueByteArrayIterator kv = new KeyStringValueByteArrayIterator();	1✔
122	copy(raw, kv);	1✔
123	kv.setValue(value);	1✔
124	return kv;	1✔
125	}
126
127	public static KeyStringValueByteArrayIterator iterSet(KeyValuePair<byte[], ?> raw, Iterator<byte[]> value) {
128	KeyStringValueByteArrayIterator kv = new KeyStringValueByteArrayIterator();	1✔
129	copy(raw, kv);	1✔
130	kv.setValue(value);	1✔
131	return kv;	1✔
132	}
133
134	public static KeyStringValueZSetEntryIterator iterZset(KeyValuePair<byte[], ?> raw, Iterator<ZSetEntry> value) {
135	KeyStringValueZSetEntryIterator kv = new KeyStringValueZSetEntryIterator();	1✔
136	copy(raw, kv);	1✔
137	kv.setValue(value);	1✔
138	return kv;	1✔
139	}
140
141	/*
142	* Batched
143	*/
144	public static BatchedKeyStringValueString string(KeyValuePair<byte[], ?> raw, byte[] value, int batch, boolean last) {
145	BatchedKeyStringValueString kv = new BatchedKeyStringValueString();	1✔
146	copy(raw, kv, batch, last);	1✔
147	kv.setValue(value);	1✔
148	return kv;	1✔
149	}
150
151	public static BatchedKeyStringValueModule module(KeyValuePair<byte[], ?> raw, Module value, int batch, boolean last) {
152	BatchedKeyStringValueModule kv = new BatchedKeyStringValueModule();	×
153	copy(raw, kv, batch, last);	×
154	kv.setValue(value);	×
155	return kv;	×
156	}
157
158	public static BatchedKeyStringValueHash hash(KeyValuePair<byte[], ?> raw, Map<byte[], byte[]> value, int batch, boolean last) {
159	BatchedKeyStringValueHash kv = new BatchedKeyStringValueHash();	1✔
160	copy(raw, kv, batch, last);	1✔
161	kv.setValue(value);	1✔
162	return kv;	1✔
163	}
164
165	public static BatchedKeyStringValueTTLHash ttlHash(KeyValuePair<byte[], ?> raw, Map<byte[], TTLValue> value, int batch, boolean last) {
NEW 166	BatchedKeyStringValueTTLHash kv = new BatchedKeyStringValueTTLHash();	×
167	copy(raw, kv, batch, last);	×
168	kv.setValue(value);	×
169	return kv;	×
170	}
171
172	public static BatchedKeyStringValueList list(KeyValuePair<byte[], ?> raw, List<byte[]> value, int batch, boolean last) {
173	BatchedKeyStringValueList kv = new BatchedKeyStringValueList();	1✔
174	copy(raw, kv, batch, last);	1✔
175	kv.setValue(value);	1✔
176	return kv;	1✔
177	}
178
179	public static BatchedKeyStringValueSet set(KeyValuePair<byte[], ?> raw, Set<byte[]> value, int batch, boolean last) {
180	BatchedKeyStringValueSet kv = new BatchedKeyStringValueSet();	1✔
181	copy(raw, kv, batch, last);	1✔
182	kv.setValue(value);	1✔
183	return kv;	1✔
184	}
185
186	public static BatchedKeyStringValueZSet zset(KeyValuePair<byte[], ?> raw, Set<ZSetEntry> value, int batch, boolean last) {
187	BatchedKeyStringValueZSet kv = new BatchedKeyStringValueZSet();	1✔
188	copy(raw, kv, batch, last);	1✔
189	kv.setValue(value);	1✔
190	return kv;	1✔
191	}
192
193	public static BatchedKeyStringValueStream stream(KeyValuePair<byte[], ?> raw, Stream value, int batch, boolean last) {
194	BatchedKeyStringValueStream kv = new BatchedKeyStringValueStream();	1✔
195	copy(raw, kv, batch, last);	1✔
196	kv.setValue(value);	1✔
197	return kv;	1✔
198	}
199
200	/*
201	* Helper
202	*/
203	private static void copy(KeyValuePair<byte[], ?> source, KeyValuePair<byte[], ?> target) {
204	target.setContext(source.getContext());	1✔
205	target.setDb(source.getDb());	1✔
206	target.setSlot(source.getSlot());	1✔
207	target.setExpiredType(source.getExpiredType());	1✔
208	target.setExpiredValue(source.getExpiredValue());	1✔
209	target.setEvictType(source.getEvictType());	1✔
210	target.setEvictValue(source.getEvictValue());	1✔
211	target.setValueRdbType(source.getValueRdbType());	1✔
212	target.setKey(source.getKey());	1✔
213	}	1✔
214
215	private static void copy(KeyValuePair<byte[], ?> source, BatchedKeyValuePair<byte[], ?> target, int batch, boolean last) {
216	target.setContext(source.getContext());	1✔
217	target.setDb(source.getDb());	1✔
218	target.setSlot(source.getSlot());	1✔
219	target.setExpiredType(source.getExpiredType());	1✔
220	target.setExpiredValue(source.getExpiredValue());	1✔
221	target.setEvictType(source.getEvictType());	1✔
222	target.setEvictValue(source.getEvictValue());	1✔
223	target.setValueRdbType(source.getValueRdbType());	1✔
224	target.setKey(source.getKey());	1✔
225	target.setBatch(batch);	1✔
226	target.setLast(last);	1✔
227	}	1✔
228	}

leonchen83 / redis-replicator / #2187

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous