001/**
002 * Copyright (c) 2015-2022, Michael Yang 杨福海 (fuhai999@gmail.com).
003 * <p>
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 * <p>
008 * http://www.apache.org/licenses/LICENSE-2.0
009 * <p>
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package io.jboot.web.converter;
017
018import com.jfinal.core.converter.IConverter;
019import com.jfinal.core.converter.TypeConverter;
020import io.jboot.utils.StrUtil;
021
022import java.math.BigDecimal;
023import java.math.BigInteger;
024
025/**
026 * 针对 数组 类型实现 IConverter 接口
027 */
028public class ArrayConverters {
029
030    private static String array_separator = ",";
031
032    public static String getArraySeparator() {
033        return array_separator;
034    }
035
036    public static void setArraySeparator(String arraySeparator) {
037        ArrayConverters.array_separator = arraySeparator;
038    }
039
040    public static class IntArrayConverter implements IConverter<int[]> {
041        @Override
042        public int[] convert(String s) {
043            String[] strings = s.split(array_separator);
044            int[] ret = new int[strings.length];
045            for (int i = 0; i < strings.length; i++) {
046                String str = strings[i];
047                ret[i] = StrUtil.isBlank(str) ? 0 : Integer.parseInt(str);
048            }
049            return ret;
050        }
051    }
052
053
054    public static class Int1ArrayConverter implements IConverter<Integer[]> {
055        @Override
056        public Integer[] convert(String s) {
057            String[] strings = s.split(array_separator);
058            Integer[] ret = new Integer[strings.length];
059            for (int i = 0; i < strings.length; i++) {
060                String str = strings[i];
061                ret[i] = StrUtil.isBlank(str) ? null : Integer.parseInt(str);
062            }
063            return ret;
064        }
065    }
066
067
068    public static class LongArrayConverter implements IConverter<long[]> {
069        @Override
070        public long[] convert(String s) {
071            String[] strings = s.split(array_separator);
072            long[] ret = new long[strings.length];
073            for (int i = 0; i < strings.length; i++) {
074                String str = strings[i];
075                ret[i] = StrUtil.isBlank(str) ? 0 : Long.parseLong(str);
076            }
077            return ret;
078        }
079    }
080
081
082    public static class Long1ArrayConverter implements IConverter<Long[]> {
083        @Override
084        public Long[] convert(String s) {
085            String[] strings = s.split(array_separator);
086            Long[] ret = new Long[strings.length];
087            for (int i = 0; i < strings.length; i++) {
088                String str = strings[i];
089                ret[i] = StrUtil.isBlank(str) ? null : Long.parseLong(str);
090            }
091            return ret;
092        }
093    }
094
095
096    public static class FloatArrayConverter implements IConverter<float[]> {
097        @Override
098        public float[] convert(String s) {
099            String[] strings = s.split(array_separator);
100            float[] ret = new float[strings.length];
101            for (int i = 0; i < strings.length; i++) {
102                String str = strings[i];
103                ret[i] = StrUtil.isBlank(str) ? 0 : Float.parseFloat(str);
104            }
105            return ret;
106        }
107    }
108
109
110    public static class Float1ArrayConverter implements IConverter<Float[]> {
111        @Override
112        public Float[] convert(String s) {
113            String[] strings = s.split(array_separator);
114            Float[] ret = new Float[strings.length];
115            for (int i = 0; i < strings.length; i++) {
116                String str = strings[i];
117                ret[i] = StrUtil.isBlank(str) ? null : Float.parseFloat(str);
118            }
119            return ret;
120        }
121    }
122
123    public static class DoubleArrayConverter implements IConverter<double[]> {
124        @Override
125        public double[] convert(String s) {
126            String[] strings = s.split(array_separator);
127            double[] ret = new double[strings.length];
128            for (int i = 0; i < strings.length; i++) {
129                String str = strings[i];
130                ret[i] = StrUtil.isBlank(str) ? 0 : Double.parseDouble(str);
131            }
132            return ret;
133        }
134    }
135
136
137    public static class Double1ArrayConverter implements IConverter<Double[]> {
138        @Override
139        public Double[] convert(String s) {
140            String[] strings = s.split(array_separator);
141            Double[] ret = new Double[strings.length];
142            for (int i = 0; i < strings.length; i++) {
143                String str = strings[i];
144                ret[i] = StrUtil.isBlank(str) ? null : Double.parseDouble(str);
145            }
146            return ret;
147        }
148    }
149
150
151    public static class BigIntegerArrayConverter implements IConverter<BigInteger[]> {
152        @Override
153        public BigInteger[] convert(String s) {
154            String[] strings = s.split(array_separator);
155            BigInteger[] ret = new BigInteger[strings.length];
156            for (int i = 0; i < strings.length; i++) {
157                String str = strings[i];
158                ret[i] = StrUtil.isBlank(str) ? null : new BigInteger(str);
159            }
160            return ret;
161        }
162    }
163
164
165    public static class BigDecimalArrayConverter implements IConverter<BigDecimal[]> {
166        @Override
167        public BigDecimal[] convert(String s) {
168            String[] strings = s.split(array_separator);
169            BigDecimal[] ret = new BigDecimal[strings.length];
170            for (int i = 0; i < strings.length; i++) {
171                String str = strings[i];
172                ret[i] = StrUtil.isBlank(str) ? null : new BigDecimal(str);
173            }
174            return ret;
175        }
176    }
177
178
179    public static void init() {
180        TypeConverter.me().regist(int[].class, new IntArrayConverter());
181        TypeConverter.me().regist(Integer[].class, new Int1ArrayConverter());
182
183        TypeConverter.me().regist(long[].class, new LongArrayConverter());
184        TypeConverter.me().regist(Long[].class, new Long1ArrayConverter());
185
186        TypeConverter.me().regist(float[].class, new FloatArrayConverter());
187        TypeConverter.me().regist(Float[].class, new Float1ArrayConverter());
188
189        TypeConverter.me().regist(double[].class, new DoubleArrayConverter());
190        TypeConverter.me().regist(Double[].class, new Double1ArrayConverter());
191
192        TypeConverter.me().regist(BigInteger[].class, new BigIntegerArrayConverter());
193        TypeConverter.me().regist(BigDecimal[].class, new BigDecimalArrayConverter());
194    }
195
196}