#405

Committed 16 Apr 2024 05:58AM UTC coverage: 0.0% (-88.9%) from 88.866%

Build # #405

Build Type

push

Committed by

Commit Message

add encoding to fix coverage report

Run Details

0 of 5353 relevant lines covered (0.0%)

0.0 hits per line

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

0.0

/jetcache-anno/src/main/java/com/alicp/jetcache/anno/support/DefaultEncoderParser.java

/**
 * Created on 2019/6/7.
 */
package com.alicp.jetcache.anno.support;

import com.alicp.jetcache.CacheConfigException;
import com.alicp.jetcache.anno.SerialPolicy;
import com.alicp.jetcache.support.JavaValueDecoder;
import com.alicp.jetcache.support.JavaValueEncoder;
import com.alicp.jetcache.support.Kryo5ValueDecoder;
import com.alicp.jetcache.support.Kryo5ValueEncoder;
import com.alicp.jetcache.support.KryoValueDecoder;
import com.alicp.jetcache.support.KryoValueEncoder;

import java.net.URI;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

/**
 * @author huangli
 */
public class DefaultEncoderParser implements EncoderParser {
    protected static Map<String, String> parseQueryParameters(String query) {
        Map<String, String> m = new HashMap<>();
        if (query != null) {
            String[] pairs = query.split("&");
            for (String pair : pairs) {
                int idx = pair.indexOf("=");
                String key = idx > 0 ? pair.substring(0, idx) : pair;
                String value = idx > 0 && pair.length() > idx + 1 ? pair.substring(idx + 1) : null;
                if (key != null && value != null) {
                    m.put(key, value);
                }
            }
        }
        return m;
    }

    JavaValueDecoder javaValueDecoder(boolean useIdentityNumber) {
        return new JavaValueDecoder(useIdentityNumber);
    }

    @Override
    public Function<Object, byte[]> parseEncoder(String valueEncoder) {
        if (valueEncoder == null) {
            throw new CacheConfigException("no serialPolicy");
        }
        valueEncoder = valueEncoder.trim();
        URI uri = URI.create(valueEncoder);
        valueEncoder = uri.getPath();
        boolean useIdentityNumber = isUseIdentityNumber(uri);
        if (SerialPolicy.KRYO.equalsIgnoreCase(valueEncoder)) {
            return new KryoValueEncoder(useIdentityNumber);
        } else if (SerialPolicy.JAVA.equalsIgnoreCase(valueEncoder)) {
            return new JavaValueEncoder(useIdentityNumber);
        } else if (SerialPolicy.KRYO5.equalsIgnoreCase(valueEncoder)) {
            return new Kryo5ValueEncoder(useIdentityNumber);
        }/* else if (SerialPolicy.FASTJSON2.equalsIgnoreCase(valueEncoder)) {
            return new Fastjson2ValueEncoder(useIdentityNumber);
        }*/ else {
            throw new CacheConfigException("not supported:" + valueEncoder);
        }
    }

    private boolean isUseIdentityNumber(URI uri) {
        Map<String, String> params = parseQueryParameters(uri.getQuery());
        boolean useIdentityNumber = true;
        if ("false".equalsIgnoreCase(params.get("useIdentityNumber"))) {
            useIdentityNumber = false;
        }
        return useIdentityNumber;
    }

    @Override
    public Function<byte[], Object> parseDecoder(String valueDecoder) {
        if (valueDecoder == null) {
            throw new CacheConfigException("no serialPolicy");
        }
        valueDecoder = valueDecoder.trim();
        URI uri = URI.create(valueDecoder);
        valueDecoder = uri.getPath();
        boolean useIdentityNumber = isUseIdentityNumber(uri);
        if (SerialPolicy.KRYO.equalsIgnoreCase(valueDecoder)) {
            return new KryoValueDecoder(useIdentityNumber);
        } else if (SerialPolicy.JAVA.equalsIgnoreCase(valueDecoder)) {
            return javaValueDecoder(useIdentityNumber);
        } else if (SerialPolicy.KRYO5.equalsIgnoreCase(valueDecoder)) {
            return new Kryo5ValueDecoder(useIdentityNumber);
        }/* else if (SerialPolicy.FASTJSON2.equalsIgnoreCase(valueDecoder)) {
            return new Kryo5ValueDecoder(useIdentityNumber);
        }*/ else {
            throw new CacheConfigException("not supported:" + valueDecoder);
        }
    }
}

1	/**
2	* Created on 2019/6/7.
3	*/
4	package com.alicp.jetcache.anno.support;
5
6	import com.alicp.jetcache.CacheConfigException;
7	import com.alicp.jetcache.anno.SerialPolicy;
8	import com.alicp.jetcache.support.JavaValueDecoder;
9	import com.alicp.jetcache.support.JavaValueEncoder;
10	import com.alicp.jetcache.support.Kryo5ValueDecoder;
11	import com.alicp.jetcache.support.Kryo5ValueEncoder;
12	import com.alicp.jetcache.support.KryoValueDecoder;
13	import com.alicp.jetcache.support.KryoValueEncoder;
14
15	import java.net.URI;
16	import java.util.HashMap;
17	import java.util.Map;
18	import java.util.function.Function;
19
20	/**
21	* @author huangli
22	*/
23	public class DefaultEncoderParser implements EncoderParser {	×
24	protected static Map<String, String> parseQueryParameters(String query) {
25	Map<String, String> m = new HashMap<>();	×
26	if (query != null) {	×
27	String[] pairs = query.split("&");	×
28	for (String pair : pairs) {	×
29	int idx = pair.indexOf("=");	×
30	String key = idx > 0 ? pair.substring(0, idx) : pair;	×
31	String value = idx > 0 && pair.length() > idx + 1 ? pair.substring(idx + 1) : null;	×
32	if (key != null && value != null) {	×
33	m.put(key, value);	×
34	}
35	}
36	}
37	return m;	×
38	}
39
40	JavaValueDecoder javaValueDecoder(boolean useIdentityNumber) {
41	return new JavaValueDecoder(useIdentityNumber);	×
42	}
43
44	@Override
45	public Function<Object, byte[]> parseEncoder(String valueEncoder) {
46	if (valueEncoder == null) {	×
47	throw new CacheConfigException("no serialPolicy");	×
48	}
49	valueEncoder = valueEncoder.trim();	×
50	URI uri = URI.create(valueEncoder);	×
51	valueEncoder = uri.getPath();	×
52	boolean useIdentityNumber = isUseIdentityNumber(uri);	×
53	if (SerialPolicy.KRYO.equalsIgnoreCase(valueEncoder)) {	×
54	return new KryoValueEncoder(useIdentityNumber);	×
55	} else if (SerialPolicy.JAVA.equalsIgnoreCase(valueEncoder)) {	×
56	return new JavaValueEncoder(useIdentityNumber);	×
57	} else if (SerialPolicy.KRYO5.equalsIgnoreCase(valueEncoder)) {	×
58	return new Kryo5ValueEncoder(useIdentityNumber);	×
59	}/* else if (SerialPolicy.FASTJSON2.equalsIgnoreCase(valueEncoder)) {
60	return new Fastjson2ValueEncoder(useIdentityNumber);
61	}*/ else {
62	throw new CacheConfigException("not supported:" + valueEncoder);	×
63	}
64	}
65
66	private boolean isUseIdentityNumber(URI uri) {
67	Map<String, String> params = parseQueryParameters(uri.getQuery());	×
68	boolean useIdentityNumber = true;	×
69	if ("false".equalsIgnoreCase(params.get("useIdentityNumber"))) {	×
70	useIdentityNumber = false;	×
71	}
72	return useIdentityNumber;	×
73	}
74
75	@Override
76	public Function<byte[], Object> parseDecoder(String valueDecoder) {
77	if (valueDecoder == null) {	×
78	throw new CacheConfigException("no serialPolicy");	×
79	}
80	valueDecoder = valueDecoder.trim();	×
81	URI uri = URI.create(valueDecoder);	×
82	valueDecoder = uri.getPath();	×
83	boolean useIdentityNumber = isUseIdentityNumber(uri);	×
84	if (SerialPolicy.KRYO.equalsIgnoreCase(valueDecoder)) {	×
85	return new KryoValueDecoder(useIdentityNumber);	×
86	} else if (SerialPolicy.JAVA.equalsIgnoreCase(valueDecoder)) {	×
87	return javaValueDecoder(useIdentityNumber);	×
88	} else if (SerialPolicy.KRYO5.equalsIgnoreCase(valueDecoder)) {	×
89	return new Kryo5ValueDecoder(useIdentityNumber);	×
90	}/* else if (SerialPolicy.FASTJSON2.equalsIgnoreCase(valueDecoder)) {
91	return new Kryo5ValueDecoder(useIdentityNumber);
92	}*/ else {
93	throw new CacheConfigException("not supported:" + valueDecoder);	×
94	}
95	}
96	}

alibaba / jetcache / #405

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