#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

0.0

/src/main/java/com/moilioncircle/redis/replicator/rdb/skip/SkipRdbValueVisitor.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.skip;

import static com.moilioncircle.redis.replicator.Constants.MODULE_SET;

import java.io.IOException;
import java.util.NoSuchElementException;

import com.moilioncircle.redis.replicator.Replicator;
import com.moilioncircle.redis.replicator.io.RedisInputStream;
import com.moilioncircle.redis.replicator.rdb.DefaultRdbValueVisitor;
import com.moilioncircle.redis.replicator.rdb.datatype.Module;
import com.moilioncircle.redis.replicator.rdb.module.ModuleParser;

/**
 * @author Baoyi Chen
 * @since 3.6.3
 */
public class SkipRdbValueVisitor extends DefaultRdbValueVisitor {
    
    public SkipRdbValueVisitor(Replicator replicator) {
        super(replicator);
    }
    
    @Override
    public <T> T applyFunction(RedisInputStream in, int version) throws IOException {
        SkipRdbParser parser = new SkipRdbParser(in);
        parser.rdbGenericLoadStringObject(); // name
        parser.rdbGenericLoadStringObject(); // engine name
        long hasDesc = parser.rdbLoadLen().len;
        if (hasDesc == 1) {
            parser.rdbGenericLoadStringObject(); // description
        }
        parser.rdbGenericLoadStringObject(); // code
        return null;
    }
    
    @Override
    public <T> T applyFunction2(RedisInputStream in, int version) throws IOException {
        SkipRdbParser parser = new SkipRdbParser(in);
        parser.rdbGenericLoadStringObject(); // code
        return null;
    }
    
    @Override
    public <T> T applyString(RedisInputStream in, int version) throws IOException {
        SkipRdbParser parser = new SkipRdbParser(in);
        parser.rdbLoadEncodedStringObject();
        return null;
    }
    
    @Override
    public <T> T applyList(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        long len = skip.rdbLoadLen().len;
        while (len > 0) {
            skip.rdbLoadEncodedStringObject();
            len--;
        }
        return null;
    }
    
    @Override
    public <T> T applySet(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        long len = skip.rdbLoadLen().len;
        while (len > 0) {
            skip.rdbLoadEncodedStringObject();
            len--;
        }
        return null;
    }
    
    @Override
    public <T> T applySetListPack(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        skip.rdbLoadPlainStringObject();
        return null;
    }
    
    @Override
    public <T> T applyZSet(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        long len = skip.rdbLoadLen().len;
        while (len > 0) {
            skip.rdbLoadEncodedStringObject();
            skip.rdbLoadDoubleValue();
            len--;
        }
        return null;
    }
    
    @Override
    public <T> T applyZSet2(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        long len = skip.rdbLoadLen().len;
        while (len > 0) {
            skip.rdbLoadEncodedStringObject();
            skip.rdbLoadBinaryDoubleValue();
            len--;
        }
        return null;
    }
    
    @Override
    public <T> T applyHash(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        long len = skip.rdbLoadLen().len;
        while (len > 0) {
            skip.rdbLoadEncodedStringObject();
            skip.rdbLoadEncodedStringObject();
            len--;
        }
        return null;
    }
    
    @Override
    public <T> T applyHashZipMap(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        skip.rdbLoadPlainStringObject();
        return null;
    }
    
    @Override
    public <T> T applyListZipList(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        skip.rdbLoadPlainStringObject();
        return null;
    }
    
    @Override
    public <T> T applySetIntSet(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        skip.rdbLoadPlainStringObject();
        return null;
    }
    
    @Override
    public <T> T applyZSetZipList(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        skip.rdbLoadPlainStringObject();
        return null;
    }
    
    @Override
    public <T> T applyZSetListPack(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        skip.rdbLoadPlainStringObject();
        return null;
    }
    
    @Override
    public <T> T applyHashZipList(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        skip.rdbLoadPlainStringObject();
        return null;
    }
    
    @Override
    public <T> T applyHashListPack(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        skip.rdbLoadPlainStringObject();
        return null;
    }
    
    @Override
    public <T> T applyListQuickList(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        long len = skip.rdbLoadLen().len;
        for (long i = 0; i < len; i++) {
            skip.rdbGenericLoadStringObject();
        }
        return null;
    }
    
    @Override
    public <T> T applyListQuickList2(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        long len = skip.rdbLoadLen().len;
        for (long i = 0; i < len; i++) {
            skip.rdbLoadLen();
            skip.rdbGenericLoadStringObject();
        }
        return null;
    }
    
    @Override
    public <T> T applyModule(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        char[] c = new char[9];
        long moduleid = skip.rdbLoadLen().len;
        for (int i = 0; i < c.length; i++) {
            c[i] = MODULE_SET[(int) (moduleid >>> (10 + (c.length - 1 - i) * 6) & 63)];
        }
        String moduleName = new String(c);
        int moduleVersion = (int) (moduleid & 1023);
        ModuleParser<? extends Module> moduleParser = replicator.getModuleParser(moduleName, moduleVersion);
        if (moduleParser == null) {
            throw new NoSuchElementException("module parser[" + moduleName + ", " + moduleVersion + "] not register. rdb type: [RDB_TYPE_MODULE]");
        }
        moduleParser.parse(in, 1);
        return null;
    }
    
    @Override
    public <T> T applyModule2(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        skip.rdbLoadLen();
        SkipRdbParser skipRdbParser = new SkipRdbParser(in);
        skipRdbParser.rdbLoadCheckModuleValue();
        return null;
    }
    
    @Override
    public <T> T applyStreamListPacks(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        long listPacks = skip.rdbLoadLen().len;
        while (listPacks-- > 0) {
            skip.rdbLoadPlainStringObject();
            skip.rdbLoadPlainStringObject();
        }
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        long groupCount = skip.rdbLoadLen().len;
        while (groupCount-- > 0) {
            skip.rdbLoadPlainStringObject();
            skip.rdbLoadLen();
            skip.rdbLoadLen();
            long groupPel = skip.rdbLoadLen().len;
            while (groupPel-- > 0) {
                in.skip(16);
                skip.rdbLoadMillisecondTime();
                skip.rdbLoadLen();
            }
            long consumerCount = skip.rdbLoadLen().len;
            while (consumerCount-- > 0) {
                skip.rdbLoadPlainStringObject();
                skip.rdbLoadMillisecondTime();
                long consumerPel = skip.rdbLoadLen().len;
                while (consumerPel-- > 0) {
                    in.skip(16);
                }
            }
        }
        return null;
    }
    
    @Override
    public <T> T applyStreamListPacks2(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        long listPacks = skip.rdbLoadLen().len;
        while (listPacks-- > 0) {
            skip.rdbLoadPlainStringObject();
            skip.rdbLoadPlainStringObject();
        }
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        long groupCount = skip.rdbLoadLen().len;
        while (groupCount-- > 0) {
            skip.rdbLoadPlainStringObject();
            skip.rdbLoadLen();
            skip.rdbLoadLen();
            skip.rdbLoadLen();
            long groupPel = skip.rdbLoadLen().len;
            while (groupPel-- > 0) {
                in.skip(16);
                skip.rdbLoadMillisecondTime();
                skip.rdbLoadLen();
            }
            long consumerCount = skip.rdbLoadLen().len;
            while (consumerCount-- > 0) {
                skip.rdbLoadPlainStringObject();
                skip.rdbLoadMillisecondTime();
                long consumerPel = skip.rdbLoadLen().len;
                while (consumerPel-- > 0) {
                    in.skip(16);
                }
            }
        }
        return null;
    }
    
    @Override
    public <T> T applyStreamListPacks3(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        long listPacks = skip.rdbLoadLen().len;
        while (listPacks-- > 0) {
            skip.rdbLoadPlainStringObject();
            skip.rdbLoadPlainStringObject();
        }
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        skip.rdbLoadLen();
        long groupCount = skip.rdbLoadLen().len;
        while (groupCount-- > 0) {
            skip.rdbLoadPlainStringObject();
            skip.rdbLoadLen();
            skip.rdbLoadLen();
            skip.rdbLoadLen();
            long groupPel = skip.rdbLoadLen().len;
            while (groupPel-- > 0) {
                in.skip(16);
                skip.rdbLoadMillisecondTime();
                skip.rdbLoadLen();
            }
            long consumerCount = skip.rdbLoadLen().len;
            while (consumerCount-- > 0) {
                skip.rdbLoadPlainStringObject();
                skip.rdbLoadMillisecondTime();
                skip.rdbLoadMillisecondTime();
                long consumerPel = skip.rdbLoadLen().len;
                while (consumerPel-- > 0) {
                    in.skip(16);
                }
            }
        }
        return null;
    }
    
    @Override
    public <T> T applyHashMetadata(RedisInputStream in, int version) throws IOException{
        // TODO
        return null;
    }
    
    @Override
    public <T> T applyHashListPackEx(RedisInputStream in, int version) throws IOException {
        // TODO
        return null;
    }
}

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.skip;
18
19	import static com.moilioncircle.redis.replicator.Constants.MODULE_SET;
20
21	import java.io.IOException;
22	import java.util.NoSuchElementException;
23
24	import com.moilioncircle.redis.replicator.Replicator;
25	import com.moilioncircle.redis.replicator.io.RedisInputStream;
26	import com.moilioncircle.redis.replicator.rdb.DefaultRdbValueVisitor;
27	import com.moilioncircle.redis.replicator.rdb.datatype.Module;
28	import com.moilioncircle.redis.replicator.rdb.module.ModuleParser;
29
30	/**
31	* @author Baoyi Chen
32	* @since 3.6.3
33	*/
34	public class SkipRdbValueVisitor extends DefaultRdbValueVisitor {
35
36	public SkipRdbValueVisitor(Replicator replicator) {
37	super(replicator);	×
38	}	×
39
40	@Override
41	public <T> T applyFunction(RedisInputStream in, int version) throws IOException {
42	SkipRdbParser parser = new SkipRdbParser(in);	×
43	parser.rdbGenericLoadStringObject(); // name	×
44	parser.rdbGenericLoadStringObject(); // engine name	×
45	long hasDesc = parser.rdbLoadLen().len;	×
46	if (hasDesc == 1) {	×
47	parser.rdbGenericLoadStringObject(); // description	×
48	}
49	parser.rdbGenericLoadStringObject(); // code	×
50	return null;	×
51	}
52
53	@Override
54	public <T> T applyFunction2(RedisInputStream in, int version) throws IOException {
55	SkipRdbParser parser = new SkipRdbParser(in);	×
56	parser.rdbGenericLoadStringObject(); // code	×
57	return null;	×
58	}
59
60	@Override
61	public <T> T applyString(RedisInputStream in, int version) throws IOException {
62	SkipRdbParser parser = new SkipRdbParser(in);	×
63	parser.rdbLoadEncodedStringObject();	×
64	return null;	×
65	}
66
67	@Override
68	public <T> T applyList(RedisInputStream in, int version) throws IOException {
69	SkipRdbParser skip = new SkipRdbParser(in);	×
70	long len = skip.rdbLoadLen().len;	×
71	while (len > 0) {	×
72	skip.rdbLoadEncodedStringObject();	×
73	len--;	×
74	}
75	return null;	×
76	}
77
78	@Override
79	public <T> T applySet(RedisInputStream in, int version) throws IOException {
80	SkipRdbParser skip = new SkipRdbParser(in);	×
81	long len = skip.rdbLoadLen().len;	×
82	while (len > 0) {	×
83	skip.rdbLoadEncodedStringObject();	×
84	len--;	×
85	}
86	return null;	×
87	}
88
89	@Override
90	public <T> T applySetListPack(RedisInputStream in, int version) throws IOException {
91	SkipRdbParser skip = new SkipRdbParser(in);	×
92	skip.rdbLoadPlainStringObject();	×
93	return null;	×
94	}
95
96	@Override
97	public <T> T applyZSet(RedisInputStream in, int version) throws IOException {
98	SkipRdbParser skip = new SkipRdbParser(in);	×
99	long len = skip.rdbLoadLen().len;	×
100	while (len > 0) {	×
101	skip.rdbLoadEncodedStringObject();	×
102	skip.rdbLoadDoubleValue();	×
103	len--;	×
104	}
105	return null;	×
106	}
107
108	@Override
109	public <T> T applyZSet2(RedisInputStream in, int version) throws IOException {
110	SkipRdbParser skip = new SkipRdbParser(in);	×
111	long len = skip.rdbLoadLen().len;	×
112	while (len > 0) {	×
113	skip.rdbLoadEncodedStringObject();	×
114	skip.rdbLoadBinaryDoubleValue();	×
115	len--;	×
116	}
117	return null;	×
118	}
119
120	@Override
121	public <T> T applyHash(RedisInputStream in, int version) throws IOException {
122	SkipRdbParser skip = new SkipRdbParser(in);	×
123	long len = skip.rdbLoadLen().len;	×
124	while (len > 0) {	×
125	skip.rdbLoadEncodedStringObject();	×
126	skip.rdbLoadEncodedStringObject();	×
127	len--;	×
128	}
129	return null;	×
130	}
131
132	@Override
133	public <T> T applyHashZipMap(RedisInputStream in, int version) throws IOException {
134	SkipRdbParser skip = new SkipRdbParser(in);	×
135	skip.rdbLoadPlainStringObject();	×
136	return null;	×
137	}
138
139	@Override
140	public <T> T applyListZipList(RedisInputStream in, int version) throws IOException {
141	SkipRdbParser skip = new SkipRdbParser(in);	×
142	skip.rdbLoadPlainStringObject();	×
143	return null;	×
144	}
145
146	@Override
147	public <T> T applySetIntSet(RedisInputStream in, int version) throws IOException {
148	SkipRdbParser skip = new SkipRdbParser(in);	×
149	skip.rdbLoadPlainStringObject();	×
150	return null;	×
151	}
152
153	@Override
154	public <T> T applyZSetZipList(RedisInputStream in, int version) throws IOException {
155	SkipRdbParser skip = new SkipRdbParser(in);	×
156	skip.rdbLoadPlainStringObject();	×
157	return null;	×
158	}
159
160	@Override
161	public <T> T applyZSetListPack(RedisInputStream in, int version) throws IOException {
162	SkipRdbParser skip = new SkipRdbParser(in);	×
163	skip.rdbLoadPlainStringObject();	×
164	return null;	×
165	}
166
167	@Override
168	public <T> T applyHashZipList(RedisInputStream in, int version) throws IOException {
169	SkipRdbParser skip = new SkipRdbParser(in);	×
170	skip.rdbLoadPlainStringObject();	×
171	return null;	×
172	}
173
174	@Override
175	public <T> T applyHashListPack(RedisInputStream in, int version) throws IOException {
176	SkipRdbParser skip = new SkipRdbParser(in);	×
177	skip.rdbLoadPlainStringObject();	×
178	return null;	×
179	}
180
181	@Override
182	public <T> T applyListQuickList(RedisInputStream in, int version) throws IOException {
183	SkipRdbParser skip = new SkipRdbParser(in);	×
184	long len = skip.rdbLoadLen().len;	×
185	for (long i = 0; i < len; i++) {	×
186	skip.rdbGenericLoadStringObject();	×
187	}
188	return null;	×
189	}
190
191	@Override
192	public <T> T applyListQuickList2(RedisInputStream in, int version) throws IOException {
193	SkipRdbParser skip = new SkipRdbParser(in);	×
194	long len = skip.rdbLoadLen().len;	×
195	for (long i = 0; i < len; i++) {	×
196	skip.rdbLoadLen();	×
197	skip.rdbGenericLoadStringObject();	×
198	}
199	return null;	×
200	}
201
202	@Override
203	public <T> T applyModule(RedisInputStream in, int version) throws IOException {
204	SkipRdbParser skip = new SkipRdbParser(in);	×
205	char[] c = new char[9];	×
206	long moduleid = skip.rdbLoadLen().len;	×
207	for (int i = 0; i < c.length; i++) {	×
208	c[i] = MODULE_SET[(int) (moduleid >>> (10 + (c.length - 1 - i) * 6) & 63)];	×
209	}
210	String moduleName = new String(c);	×
211	int moduleVersion = (int) (moduleid & 1023);	×
212	ModuleParser<? extends Module> moduleParser = replicator.getModuleParser(moduleName, moduleVersion);	×
213	if (moduleParser == null) {	×
214	throw new NoSuchElementException("module parser[" + moduleName + ", " + moduleVersion + "] not register. rdb type: [RDB_TYPE_MODULE]");	×
215	}
216	moduleParser.parse(in, 1);	×
217	return null;	×
218	}
219
220	@Override
221	public <T> T applyModule2(RedisInputStream in, int version) throws IOException {
222	SkipRdbParser skip = new SkipRdbParser(in);	×
223	skip.rdbLoadLen();	×
224	SkipRdbParser skipRdbParser = new SkipRdbParser(in);	×
225	skipRdbParser.rdbLoadCheckModuleValue();	×
226	return null;	×
227	}
228
229	@Override
230	public <T> T applyStreamListPacks(RedisInputStream in, int version) throws IOException {
231	SkipRdbParser skip = new SkipRdbParser(in);	×
232	long listPacks = skip.rdbLoadLen().len;	×
233	while (listPacks-- > 0) {	×
234	skip.rdbLoadPlainStringObject();	×
235	skip.rdbLoadPlainStringObject();	×
236	}
237	skip.rdbLoadLen();	×
238	skip.rdbLoadLen();	×
239	skip.rdbLoadLen();	×
240	long groupCount = skip.rdbLoadLen().len;	×
241	while (groupCount-- > 0) {	×
242	skip.rdbLoadPlainStringObject();	×
243	skip.rdbLoadLen();	×
244	skip.rdbLoadLen();	×
245	long groupPel = skip.rdbLoadLen().len;	×
246	while (groupPel-- > 0) {	×
247	in.skip(16);	×
248	skip.rdbLoadMillisecondTime();	×
249	skip.rdbLoadLen();	×
250	}
251	long consumerCount = skip.rdbLoadLen().len;	×
252	while (consumerCount-- > 0) {	×
253	skip.rdbLoadPlainStringObject();	×
254	skip.rdbLoadMillisecondTime();	×
255	long consumerPel = skip.rdbLoadLen().len;	×
256	while (consumerPel-- > 0) {	×
257	in.skip(16);	×
258	}
259	}	×
260	}	×
261	return null;	×
262	}
263
264	@Override
265	public <T> T applyStreamListPacks2(RedisInputStream in, int version) throws IOException {
266	SkipRdbParser skip = new SkipRdbParser(in);	×
267	long listPacks = skip.rdbLoadLen().len;	×
268	while (listPacks-- > 0) {	×
269	skip.rdbLoadPlainStringObject();	×
270	skip.rdbLoadPlainStringObject();	×
271	}
272	skip.rdbLoadLen();	×
273	skip.rdbLoadLen();	×
274	skip.rdbLoadLen();	×
275	skip.rdbLoadLen();	×
276	skip.rdbLoadLen();	×
277	skip.rdbLoadLen();	×
278	skip.rdbLoadLen();	×
279	skip.rdbLoadLen();	×
280	long groupCount = skip.rdbLoadLen().len;	×
281	while (groupCount-- > 0) {	×
282	skip.rdbLoadPlainStringObject();	×
283	skip.rdbLoadLen();	×
284	skip.rdbLoadLen();	×
285	skip.rdbLoadLen();	×
286	long groupPel = skip.rdbLoadLen().len;	×
287	while (groupPel-- > 0) {	×
288	in.skip(16);	×
289	skip.rdbLoadMillisecondTime();	×
290	skip.rdbLoadLen();	×
291	}
292	long consumerCount = skip.rdbLoadLen().len;	×
293	while (consumerCount-- > 0) {	×
294	skip.rdbLoadPlainStringObject();	×
295	skip.rdbLoadMillisecondTime();	×
296	long consumerPel = skip.rdbLoadLen().len;	×
297	while (consumerPel-- > 0) {	×
298	in.skip(16);	×
299	}
300	}	×
301	}	×
302	return null;	×
303	}
304
305	@Override
306	public <T> T applyStreamListPacks3(RedisInputStream in, int version) throws IOException {
307	SkipRdbParser skip = new SkipRdbParser(in);	×
308	long listPacks = skip.rdbLoadLen().len;	×
309	while (listPacks-- > 0) {	×
310	skip.rdbLoadPlainStringObject();	×
311	skip.rdbLoadPlainStringObject();	×
312	}
313	skip.rdbLoadLen();	×
314	skip.rdbLoadLen();	×
315	skip.rdbLoadLen();	×
316	skip.rdbLoadLen();	×
317	skip.rdbLoadLen();	×
318	skip.rdbLoadLen();	×
319	skip.rdbLoadLen();	×
320	skip.rdbLoadLen();	×
321	long groupCount = skip.rdbLoadLen().len;	×
322	while (groupCount-- > 0) {	×
323	skip.rdbLoadPlainStringObject();	×
324	skip.rdbLoadLen();	×
325	skip.rdbLoadLen();	×
326	skip.rdbLoadLen();	×
327	long groupPel = skip.rdbLoadLen().len;	×
328	while (groupPel-- > 0) {	×
329	in.skip(16);	×
330	skip.rdbLoadMillisecondTime();	×
331	skip.rdbLoadLen();	×
332	}
333	long consumerCount = skip.rdbLoadLen().len;	×
334	while (consumerCount-- > 0) {	×
335	skip.rdbLoadPlainStringObject();	×
336	skip.rdbLoadMillisecondTime();	×
337	skip.rdbLoadMillisecondTime();	×
338	long consumerPel = skip.rdbLoadLen().len;	×
339	while (consumerPel-- > 0) {	×
340	in.skip(16);	×
341	}
342	}	×
343	}	×
344	return null;	×
345	}
346
347	@Override
348	public <T> T applyHashMetadata(RedisInputStream in, int version) throws IOException{
349	// TODO
NEW 350	return null;	×
351	}
352
353	@Override
354	public <T> T applyHashListPackEx(RedisInputStream in, int version) throws IOException {
355	// TODO
NEW 356	return null;	×
357	}
358	}

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