#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

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 applyHashMetadata(RedisInputStream in, int version) throws IOException{
        SkipRdbParser skip = new SkipRdbParser(in);
        skip.rdbLoadMillisecondTime();
        long len = skip.rdbLoadLen().len;
        while (len > 0) {
            skip.rdbLoadLen();
            skip.rdbLoadEncodedStringObject();
            skip.rdbLoadEncodedStringObject();
            len--;
        }
        return null;
    }
    
    @Override
    public <T> T applyHashListPackEx(RedisInputStream in, int version) throws IOException {
        SkipRdbParser skip = new SkipRdbParser(in);
        skip.rdbLoadMillisecondTime();
        skip.rdbLoadPlainStringObject();
        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;
    }
}

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 applyHashMetadata(RedisInputStream in, int version) throws IOException{
NEW 204	SkipRdbParser skip = new SkipRdbParser(in);	×
NEW 205	skip.rdbLoadMillisecondTime();	×
NEW 206	long len = skip.rdbLoadLen().len;	×
NEW 207	while (len > 0) {	×
NEW 208	skip.rdbLoadLen();	×
NEW 209	skip.rdbLoadEncodedStringObject();	×
NEW 210	skip.rdbLoadEncodedStringObject();	×
NEW 211	len--;	×
212	}
NEW 213	return null;	×
214	}
215
216	@Override
217	public <T> T applyHashListPackEx(RedisInputStream in, int version) throws IOException {
NEW 218	SkipRdbParser skip = new SkipRdbParser(in);	×
NEW 219	skip.rdbLoadMillisecondTime();	×
NEW 220	skip.rdbLoadPlainStringObject();	×
NEW 221	return null;	×
222	}
223
224	@Override
225	public <T> T applyModule(RedisInputStream in, int version) throws IOException {
226	SkipRdbParser skip = new SkipRdbParser(in);	×
227	char[] c = new char[9];	×
228	long moduleid = skip.rdbLoadLen().len;	×
229	for (int i = 0; i < c.length; i++) {	×
230	c[i] = MODULE_SET[(int) (moduleid >>> (10 + (c.length - 1 - i) * 6) & 63)];	×
231	}
232	String moduleName = new String(c);	×
233	int moduleVersion = (int) (moduleid & 1023);	×
234	ModuleParser<? extends Module> moduleParser = replicator.getModuleParser(moduleName, moduleVersion);	×
235	if (moduleParser == null) {	×
236	throw new NoSuchElementException("module parser[" + moduleName + ", " + moduleVersion + "] not register. rdb type: [RDB_TYPE_MODULE]");	×
237	}
238	moduleParser.parse(in, 1);	×
239	return null;	×
240	}
241
242	@Override
243	public <T> T applyModule2(RedisInputStream in, int version) throws IOException {
244	SkipRdbParser skip = new SkipRdbParser(in);	×
245	skip.rdbLoadLen();	×
246	SkipRdbParser skipRdbParser = new SkipRdbParser(in);	×
247	skipRdbParser.rdbLoadCheckModuleValue();	×
248	return null;	×
249	}
250
251	@Override
252	public <T> T applyStreamListPacks(RedisInputStream in, int version) throws IOException {
253	SkipRdbParser skip = new SkipRdbParser(in);	×
254	long listPacks = skip.rdbLoadLen().len;	×
255	while (listPacks-- > 0) {	×
256	skip.rdbLoadPlainStringObject();	×
257	skip.rdbLoadPlainStringObject();	×
258	}
259	skip.rdbLoadLen();	×
260	skip.rdbLoadLen();	×
261	skip.rdbLoadLen();	×
262	long groupCount = skip.rdbLoadLen().len;	×
263	while (groupCount-- > 0) {	×
264	skip.rdbLoadPlainStringObject();	×
265	skip.rdbLoadLen();	×
266	skip.rdbLoadLen();	×
267	long groupPel = skip.rdbLoadLen().len;	×
268	while (groupPel-- > 0) {	×
269	in.skip(16);	×
270	skip.rdbLoadMillisecondTime();	×
271	skip.rdbLoadLen();	×
272	}
273	long consumerCount = skip.rdbLoadLen().len;	×
274	while (consumerCount-- > 0) {	×
275	skip.rdbLoadPlainStringObject();	×
276	skip.rdbLoadMillisecondTime();	×
277	long consumerPel = skip.rdbLoadLen().len;	×
278	while (consumerPel-- > 0) {	×
279	in.skip(16);	×
280	}
281	}	×
282	}	×
283	return null;	×
284	}
285
286	@Override
287	public <T> T applyStreamListPacks2(RedisInputStream in, int version) throws IOException {
288	SkipRdbParser skip = new SkipRdbParser(in);	×
289	long listPacks = skip.rdbLoadLen().len;	×
290	while (listPacks-- > 0) {	×
291	skip.rdbLoadPlainStringObject();	×
292	skip.rdbLoadPlainStringObject();	×
293	}
294	skip.rdbLoadLen();	×
295	skip.rdbLoadLen();	×
296	skip.rdbLoadLen();	×
297	skip.rdbLoadLen();	×
298	skip.rdbLoadLen();	×
299	skip.rdbLoadLen();	×
300	skip.rdbLoadLen();	×
301	skip.rdbLoadLen();	×
302	long groupCount = skip.rdbLoadLen().len;	×
303	while (groupCount-- > 0) {	×
304	skip.rdbLoadPlainStringObject();	×
305	skip.rdbLoadLen();	×
306	skip.rdbLoadLen();	×
307	skip.rdbLoadLen();	×
308	long groupPel = skip.rdbLoadLen().len;	×
309	while (groupPel-- > 0) {	×
310	in.skip(16);	×
311	skip.rdbLoadMillisecondTime();	×
312	skip.rdbLoadLen();	×
313	}
314	long consumerCount = skip.rdbLoadLen().len;	×
315	while (consumerCount-- > 0) {	×
316	skip.rdbLoadPlainStringObject();	×
317	skip.rdbLoadMillisecondTime();	×
318	long consumerPel = skip.rdbLoadLen().len;	×
319	while (consumerPel-- > 0) {	×
320	in.skip(16);	×
321	}
322	}	×
323	}	×
324	return null;	×
325	}
326
327	@Override
328	public <T> T applyStreamListPacks3(RedisInputStream in, int version) throws IOException {
329	SkipRdbParser skip = new SkipRdbParser(in);	×
330	long listPacks = skip.rdbLoadLen().len;	×
331	while (listPacks-- > 0) {	×
332	skip.rdbLoadPlainStringObject();	×
333	skip.rdbLoadPlainStringObject();	×
334	}
335	skip.rdbLoadLen();	×
336	skip.rdbLoadLen();	×
337	skip.rdbLoadLen();	×
338	skip.rdbLoadLen();	×
339	skip.rdbLoadLen();	×
340	skip.rdbLoadLen();	×
341	skip.rdbLoadLen();	×
342	skip.rdbLoadLen();	×
343	long groupCount = skip.rdbLoadLen().len;	×
344	while (groupCount-- > 0) {	×
345	skip.rdbLoadPlainStringObject();	×
346	skip.rdbLoadLen();	×
347	skip.rdbLoadLen();	×
348	skip.rdbLoadLen();	×
349	long groupPel = skip.rdbLoadLen().len;	×
350	while (groupPel-- > 0) {	×
351	in.skip(16);	×
352	skip.rdbLoadMillisecondTime();	×
353	skip.rdbLoadLen();	×
354	}
355	long consumerCount = skip.rdbLoadLen().len;	×
356	while (consumerCount-- > 0) {	×
357	skip.rdbLoadPlainStringObject();	×
358	skip.rdbLoadMillisecondTime();	×
359	skip.rdbLoadMillisecondTime();	×
360	long consumerPel = skip.rdbLoadLen().len;	×
361	while (consumerPel-- > 0) {	×
362	in.skip(16);	×
363	}
364	}	×
365	}	×
366	return null;	×
367	}
368	}

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