#2155

Committed 06 Jun 2025 04:52AM UTC coverage: 71.406% (-0.2%) from 71.609%

Build # #2155

Build Type

push

Committed by chenby

Commit Message

redis 8.0

Run Details

3 of 33 new or added lines in 14 files covered. (9.09%)

3 existing lines in 2 files now uncovered.

6635 of 9292 relevant lines covered (71.41%)

0.71 hits per line

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

98.2

/src/main/java/com/moilioncircle/redis/replicator/rdb/iterable/ValueIterableRdbVisitor.java

/*
 * Copyright 2016-2018 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.iterable;

import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_LISTPACK;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_ZIPLIST;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_ZIPMAP;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_QUICKLIST;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_QUICKLIST_2;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_ZIPLIST;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET_INTSET;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET_LISTPACK;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_2;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_LISTPACK;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_ZIPLIST;

import java.io.IOException;
import java.util.Iterator;
import java.util.Map;

import com.moilioncircle.redis.replicator.Replicator;
import com.moilioncircle.redis.replicator.event.Event;
import com.moilioncircle.redis.replicator.io.RedisInputStream;
import com.moilioncircle.redis.replicator.rdb.BaseRdbParser;
import com.moilioncircle.redis.replicator.rdb.DefaultRdbVisitor;
import com.moilioncircle.redis.replicator.rdb.RdbValueVisitor;
import com.moilioncircle.redis.replicator.rdb.datatype.ContextKeyValuePair;
import com.moilioncircle.redis.replicator.rdb.datatype.KeyValuePair;
import com.moilioncircle.redis.replicator.rdb.datatype.ZSetEntry;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueByteArrayIterator;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueMapEntryIterator;
import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueZSetEntryIterator;

/**
 * @author Leon Chen
 * @since 2.3.0
 */
public class ValueIterableRdbVisitor extends DefaultRdbVisitor {

    public ValueIterableRdbVisitor(Replicator replicator) {
        this(replicator, new ValueIterableRdbValueVisitor(replicator));
    }

    public ValueIterableRdbVisitor(Replicator replicator, RdbValueVisitor valueParser) {
        super(replicator, valueParser);
    }

    @Override
    public Event applyList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<byte[]>> o1 = new KeyStringValueByteArrayIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o1.setValueRdbType(RDB_TYPE_LIST);
        o1.setKey(key);
        o1.setValue(valueVisitor.applyList(in, version));
        return context.valueOf(o1);
    }

    @Override
    public Event applySet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<byte[]>> o2 = new KeyStringValueByteArrayIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o2.setValueRdbType(RDB_TYPE_SET);
        o2.setKey(key);
        o2.setValue(valueVisitor.applySet(in, version));
        return context.valueOf(o2);
    }
    
    @Override
    public Event applySetListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<byte[]>> o20 = new KeyStringValueByteArrayIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
    
        o20.setValueRdbType(RDB_TYPE_SET_LISTPACK);
        o20.setKey(key);
        o20.setValue(valueVisitor.applySetListPack(in, version));
        return context.valueOf(o20);
    }

    @Override
    public Event applyZSet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<ZSetEntry>> o3 = new KeyStringValueZSetEntryIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o3.setValueRdbType(RDB_TYPE_ZSET);
        o3.setKey(key);
        o3.setValue(valueVisitor.applyZSet(in, version));
        return context.valueOf(o3);
    }

    @Override
    public Event applyZSet2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<ZSetEntry>> o5 = new KeyStringValueZSetEntryIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o5.setValueRdbType(RDB_TYPE_ZSET_2);
        o5.setKey(key);
        o5.setValue(valueVisitor.applyZSet2(in, version));
        return context.valueOf(o5);
    }

    @Override
    public Event applyHash(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<Map.Entry<byte[], byte[]>>> o4 = new KeyStringValueMapEntryIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o4.setValueRdbType(RDB_TYPE_HASH);
        o4.setKey(key);
        o4.setValue(valueVisitor.applyHash(in, version));
        return context.valueOf(o4);
    }

    @Override
    public Event applyHashZipMap(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<Map.Entry<byte[], byte[]>>> o9 = new KeyStringValueMapEntryIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o9.setValueRdbType(RDB_TYPE_HASH_ZIPMAP);
        o9.setKey(key);
        o9.setValue(valueVisitor.applyHashZipMap(in, version));
        return context.valueOf(o9);
    }

    @Override
    public Event applyListZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<byte[]>> o10 = new KeyStringValueByteArrayIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o10.setValueRdbType(RDB_TYPE_LIST_ZIPLIST);
        o10.setKey(key);
        o10.setValue(valueVisitor.applyListZipList(in, version));
        return context.valueOf(o10);
    }

    @Override
    public Event applySetIntSet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<byte[]>> o11 = new KeyStringValueByteArrayIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o11.setValueRdbType(RDB_TYPE_SET_INTSET);
        o11.setKey(key);
        o11.setValue(valueVisitor.applySetIntSet(in, version));
        return context.valueOf(o11);
    }

    @Override
    public Event applyZSetZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<ZSetEntry>> o12 = new KeyStringValueZSetEntryIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o12.setValueRdbType(RDB_TYPE_ZSET_ZIPLIST);
        o12.setKey(key);
        o12.setValue(valueVisitor.applyZSetZipList(in, version));
        return context.valueOf(o12);
    }
    
    @Override
    public Event applyZSetListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<ZSetEntry>> o17 = new KeyStringValueZSetEntryIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
    
        o17.setValueRdbType(RDB_TYPE_ZSET_LISTPACK);
        o17.setKey(key);
        o17.setValue(valueVisitor.applyZSetListPack(in, version));
        return context.valueOf(o17);
    }

    @Override
    public Event applyHashZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<Map.Entry<byte[], byte[]>>> o13 = new KeyStringValueMapEntryIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o13.setValueRdbType(RDB_TYPE_HASH_ZIPLIST);
        o13.setKey(key);
        o13.setValue(valueVisitor.applyHashZipList(in, version));
        return context.valueOf(o13);
    }
    
    @Override
    public Event applyHashListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<Map.Entry<byte[], byte[]>>> o16 = new KeyStringValueMapEntryIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
    
        o16.setValueRdbType(RDB_TYPE_HASH_LISTPACK);
        o16.setKey(key);
        o16.setValue(valueVisitor.applyHashListPack(in, version));
        return context.valueOf(o16);
    }

    @Override
    public Event applyListQuickList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<byte[]>> o14 = new KeyStringValueByteArrayIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o14.setValueRdbType(RDB_TYPE_LIST_QUICKLIST);
        o14.setKey(key);
        o14.setValue(valueVisitor.applyListQuickList(in, version));
        return context.valueOf(o14);
    }
    
    @Override
    public Event applyListQuickList2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], Iterator<byte[]>> o18 = new KeyStringValueByteArrayIterator();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
    
        o18.setValueRdbType(RDB_TYPE_LIST_QUICKLIST_2);
        o18.setKey(key);
        o18.setValue(valueVisitor.applyListQuickList2(in, version));
        return context.valueOf(o18);
    }
    
    @Override
    public Event applyHashMetadata(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException{
        // TODO
        return null;
    }
    
    @Override
    public Event applyHashListPackEx(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        // TODO
        return null;
    }
}

1	/*
2	* Copyright 2016-2018 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.iterable;
18
19	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH;
20	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_LISTPACK;
21	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_ZIPLIST;
22	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_ZIPMAP;
23	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST;
24	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_QUICKLIST;
25	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_QUICKLIST_2;
26	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_ZIPLIST;
27	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET;
28	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET_INTSET;
29	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET_LISTPACK;
30	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET;
31	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_2;
32	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_LISTPACK;
33	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_ZIPLIST;
34
35	import java.io.IOException;
36	import java.util.Iterator;
37	import java.util.Map;
38
39	import com.moilioncircle.redis.replicator.Replicator;
40	import com.moilioncircle.redis.replicator.event.Event;
41	import com.moilioncircle.redis.replicator.io.RedisInputStream;
42	import com.moilioncircle.redis.replicator.rdb.BaseRdbParser;
43	import com.moilioncircle.redis.replicator.rdb.DefaultRdbVisitor;
44	import com.moilioncircle.redis.replicator.rdb.RdbValueVisitor;
45	import com.moilioncircle.redis.replicator.rdb.datatype.ContextKeyValuePair;
46	import com.moilioncircle.redis.replicator.rdb.datatype.KeyValuePair;
47	import com.moilioncircle.redis.replicator.rdb.datatype.ZSetEntry;
48	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueByteArrayIterator;
49	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueMapEntryIterator;
50	import com.moilioncircle.redis.replicator.rdb.iterable.datatype.KeyStringValueZSetEntryIterator;
51
52	/**
53	* @author Leon Chen
54	* @since 2.3.0
55	*/
56	public class ValueIterableRdbVisitor extends DefaultRdbVisitor {
57
58	public ValueIterableRdbVisitor(Replicator replicator) {
59	this(replicator, new ValueIterableRdbValueVisitor(replicator));	1✔
60	}	1✔
61
62	public ValueIterableRdbVisitor(Replicator replicator, RdbValueVisitor valueParser) {
63	super(replicator, valueParser);	1✔
64	}	1✔
65
66	@Override
67	public Event applyList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
68	BaseRdbParser parser = new BaseRdbParser(in);	1✔
69	KeyValuePair<byte[], Iterator<byte[]>> o1 = new KeyStringValueByteArrayIterator();	1✔
70	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
71
72	o1.setValueRdbType(RDB_TYPE_LIST);	1✔
73	o1.setKey(key);	1✔
74	o1.setValue(valueVisitor.applyList(in, version));	1✔
75	return context.valueOf(o1);	1✔
76	}
77
78	@Override
79	public Event applySet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
80	BaseRdbParser parser = new BaseRdbParser(in);	1✔
81	KeyValuePair<byte[], Iterator<byte[]>> o2 = new KeyStringValueByteArrayIterator();	1✔
82	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
83
84	o2.setValueRdbType(RDB_TYPE_SET);	1✔
85	o2.setKey(key);	1✔
86	o2.setValue(valueVisitor.applySet(in, version));	1✔
87	return context.valueOf(o2);	1✔
88	}
89
90	@Override
91	public Event applySetListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
92	BaseRdbParser parser = new BaseRdbParser(in);	1✔
93	KeyValuePair<byte[], Iterator<byte[]>> o20 = new KeyStringValueByteArrayIterator();	1✔
94	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
95
96	o20.setValueRdbType(RDB_TYPE_SET_LISTPACK);	1✔
97	o20.setKey(key);	1✔
98	o20.setValue(valueVisitor.applySetListPack(in, version));	1✔
99	return context.valueOf(o20);	1✔
100	}
101
102	@Override
103	public Event applyZSet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
104	BaseRdbParser parser = new BaseRdbParser(in);	1✔
105	KeyValuePair<byte[], Iterator<ZSetEntry>> o3 = new KeyStringValueZSetEntryIterator();	1✔
106	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
107
108	o3.setValueRdbType(RDB_TYPE_ZSET);	1✔
109	o3.setKey(key);	1✔
110	o3.setValue(valueVisitor.applyZSet(in, version));	1✔
111	return context.valueOf(o3);	1✔
112	}
113
114	@Override
115	public Event applyZSet2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
116	BaseRdbParser parser = new BaseRdbParser(in);	1✔
117	KeyValuePair<byte[], Iterator<ZSetEntry>> o5 = new KeyStringValueZSetEntryIterator();	1✔
118	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
119
120	o5.setValueRdbType(RDB_TYPE_ZSET_2);	1✔
121	o5.setKey(key);	1✔
122	o5.setValue(valueVisitor.applyZSet2(in, version));	1✔
123	return context.valueOf(o5);	1✔
124	}
125
126	@Override
127	public Event applyHash(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
128	BaseRdbParser parser = new BaseRdbParser(in);	1✔
129	KeyValuePair<byte[], Iterator<Map.Entry<byte[], byte[]>>> o4 = new KeyStringValueMapEntryIterator();	1✔
130	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
131
132	o4.setValueRdbType(RDB_TYPE_HASH);	1✔
133	o4.setKey(key);	1✔
134	o4.setValue(valueVisitor.applyHash(in, version));	1✔
135	return context.valueOf(o4);	1✔
136	}
137
138	@Override
139	public Event applyHashZipMap(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
140	BaseRdbParser parser = new BaseRdbParser(in);	1✔
141	KeyValuePair<byte[], Iterator<Map.Entry<byte[], byte[]>>> o9 = new KeyStringValueMapEntryIterator();	1✔
142	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
143
144	o9.setValueRdbType(RDB_TYPE_HASH_ZIPMAP);	1✔
145	o9.setKey(key);	1✔
146	o9.setValue(valueVisitor.applyHashZipMap(in, version));	1✔
147	return context.valueOf(o9);	1✔
148	}
149
150	@Override
151	public Event applyListZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
152	BaseRdbParser parser = new BaseRdbParser(in);	1✔
153	KeyValuePair<byte[], Iterator<byte[]>> o10 = new KeyStringValueByteArrayIterator();	1✔
154	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
155
156	o10.setValueRdbType(RDB_TYPE_LIST_ZIPLIST);	1✔
157	o10.setKey(key);	1✔
158	o10.setValue(valueVisitor.applyListZipList(in, version));	1✔
159	return context.valueOf(o10);	1✔
160	}
161
162	@Override
163	public Event applySetIntSet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
164	BaseRdbParser parser = new BaseRdbParser(in);	1✔
165	KeyValuePair<byte[], Iterator<byte[]>> o11 = new KeyStringValueByteArrayIterator();	1✔
166	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
167
168	o11.setValueRdbType(RDB_TYPE_SET_INTSET);	1✔
169	o11.setKey(key);	1✔
170	o11.setValue(valueVisitor.applySetIntSet(in, version));	1✔
171	return context.valueOf(o11);	1✔
172	}
173
174	@Override
175	public Event applyZSetZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
176	BaseRdbParser parser = new BaseRdbParser(in);	1✔
177	KeyValuePair<byte[], Iterator<ZSetEntry>> o12 = new KeyStringValueZSetEntryIterator();	1✔
178	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
179
180	o12.setValueRdbType(RDB_TYPE_ZSET_ZIPLIST);	1✔
181	o12.setKey(key);	1✔
182	o12.setValue(valueVisitor.applyZSetZipList(in, version));	1✔
183	return context.valueOf(o12);	1✔
184	}
185
186	@Override
187	public Event applyZSetListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
188	BaseRdbParser parser = new BaseRdbParser(in);	1✔
189	KeyValuePair<byte[], Iterator<ZSetEntry>> o17 = new KeyStringValueZSetEntryIterator();	1✔
190	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
191
192	o17.setValueRdbType(RDB_TYPE_ZSET_LISTPACK);	1✔
193	o17.setKey(key);	1✔
194	o17.setValue(valueVisitor.applyZSetListPack(in, version));	1✔
195	return context.valueOf(o17);	1✔
196	}
197
198	@Override
199	public Event applyHashZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
200	BaseRdbParser parser = new BaseRdbParser(in);	1✔
201	KeyValuePair<byte[], Iterator<Map.Entry<byte[], byte[]>>> o13 = new KeyStringValueMapEntryIterator();	1✔
202	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
203
204	o13.setValueRdbType(RDB_TYPE_HASH_ZIPLIST);	1✔
205	o13.setKey(key);	1✔
206	o13.setValue(valueVisitor.applyHashZipList(in, version));	1✔
207	return context.valueOf(o13);	1✔
208	}
209
210	@Override
211	public Event applyHashListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
212	BaseRdbParser parser = new BaseRdbParser(in);	1✔
213	KeyValuePair<byte[], Iterator<Map.Entry<byte[], byte[]>>> o16 = new KeyStringValueMapEntryIterator();	1✔
214	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
215
216	o16.setValueRdbType(RDB_TYPE_HASH_LISTPACK);	1✔
217	o16.setKey(key);	1✔
218	o16.setValue(valueVisitor.applyHashListPack(in, version));	1✔
219	return context.valueOf(o16);	1✔
220	}
221
222	@Override
223	public Event applyListQuickList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
224	BaseRdbParser parser = new BaseRdbParser(in);	1✔
225	KeyValuePair<byte[], Iterator<byte[]>> o14 = new KeyStringValueByteArrayIterator();	1✔
226	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
227
228	o14.setValueRdbType(RDB_TYPE_LIST_QUICKLIST);	1✔
229	o14.setKey(key);	1✔
230	o14.setValue(valueVisitor.applyListQuickList(in, version));	1✔
231	return context.valueOf(o14);	1✔
232	}
233
234	@Override
235	public Event applyListQuickList2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
236	BaseRdbParser parser = new BaseRdbParser(in);	1✔
237	KeyValuePair<byte[], Iterator<byte[]>> o18 = new KeyStringValueByteArrayIterator();	1✔
238	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
239
240	o18.setValueRdbType(RDB_TYPE_LIST_QUICKLIST_2);	1✔
241	o18.setKey(key);	1✔
242	o18.setValue(valueVisitor.applyListQuickList2(in, version));	1✔
243	return context.valueOf(o18);	1✔
244	}
245
246	@Override
247	public Event applyHashMetadata(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException{
248	// TODO
NEW 249	return null;	×
250	}
251
252	@Override
253	public Event applyHashListPackEx(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
254	// TODO
NEW 255	return null;	×
256	}
257	}

leonchen83 / redis-replicator / #2155

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