源代码

001// ______________________________________________________
002// Generated by sql2java - https://github.com/10km/sql2java-2-6-7 (custom branch) 
003// modified by guyadong from
004// sql2java original version https://sourceforge.net/projects/sql2java/ 
005// JDBC driver used at code generation time: com.mysql.jdbc.Driver
006// template: ibean.converter.java.vm
007// ______________________________________________________
008package net.gdface.facelog.db;
009import java.lang.reflect.ParameterizedType;
010import java.lang.reflect.Type;
011import java.util.ArrayList;
012import java.util.Collection;
013import java.util.HashMap;
014import java.util.List;
015import java.util.Map;
016import java.util.Map.Entry;
017
018/**
019 * 
020 * @author guyadong
021 *
022 * @param <L> left type
023 * @param <R> right type
024 */
025public interface IBeanConverter<L,R> {
026
027    /**
028     * Default abstract implementation of {@link IBeanConverter}<br>
029     * 
030     * @author guyadong
031     *
032     * @param <L> left type
033     * @param <R> right type
034     */
035    public static abstract class  AbstractHandle <L,R>implements IBeanConverter<L, R> {
036        /** L type  */
037        protected final Class<?> leftType;
038        /** R type  */
039        protected final Class<?> rightType;
040        private static Class<?> getRawClass(Type type){
041            if(type instanceof Class<?>){
042                return (Class<?>) type;
043            } else if(type instanceof ParameterizedType){
044                return getRawClass(((ParameterizedType) type).getRawType());
045            } else{
046                throw new IllegalArgumentException("invalid type");
047            }
048        }
049        public AbstractHandle() {
050            Type superClass = getClass().getGenericSuperclass();
051            this.leftType = getRawClass(((ParameterizedType) superClass).getActualTypeArguments()[0]);
052            this.rightType = getRawClass(((ParameterizedType) superClass).getActualTypeArguments()[1]);
053        }
054        public AbstractHandle(Class<L> leftClass,Class<R> rightClass) {
055            this.leftType = leftClass;
056            this.rightType = rightClass;
057        }
058        /** 
059         * copy right TO left, left and right must not be null
060         * @param left
061         * @param right
062         */
063        protected abstract void doFromRight(L left, R right);
064        /** 
065         * copy left TO right, left and right must not be null 
066         * @param left
067         * @param right
068         */
069        protected abstract void doToRight(L left, R right);
070        /**
071         *  Creates a new  L instance by calling constructor with an empty argument list<br>
072         *  you must override the method if the L class haven't default constructor.
073         * @return
074         */
075        @SuppressWarnings("unchecked")
076        protected L newInstanceL(){ return (L) newInstance(this.leftType); }
077        /**
078         *  Creates a new R instance by calling constructor with an empty argument list<br>
079         *  you must override the method if the R class haven't default constructor.
080         * @return
081         */
082        @SuppressWarnings("unchecked")
083        protected R newInstanceR(){ return (R) newInstance(this.rightType); }
084        
085        protected  static<T> T newInstance(Class<T>clazz){
086            try {
087                return (T) clazz.newInstance();
088            } catch (InstantiationException e) {
089                throw new RuntimeException(e);
090            } catch (IllegalAccessException e) {
091                throw new RuntimeException(e);
092            }
093        }
094        @Override
095        public L fromRight(L left, R right) {
096            if(null != right && null != left){
097                this.doFromRight(left, right);
098            }            
099            return left;
100        }
101
102        @Override
103        public R toRight(L left, R right) {
104            if(null != left && null != right){
105                this.doToRight(left, right);
106            }
107            return right;
108        }
109
110        @Override
111        public L fromRight(R bean) {
112            return null == bean? null : fromRight(newInstanceL(),bean);
113        }
114
115        @Override
116        public R toRight(L bean) {
117            return null == bean? null : toRight(bean,newInstanceR());
118        }
119
120        @Override
121        public R[] toRight(L[] lefts, R[] rights) {
122            if(null != lefts && null != rights){
123                if( lefts.length != rights.length){
124                    throw new IllegalArgumentException("mismatched length between left and right array");
125                }
126                for(int i=0;i<lefts.length;++i){
127                    this.toRight(lefts[i],rights[i]);
128                }
129            }
130            return rights;
131        }
132
133        @Override
134        public L[] fromRight(L[] lefts, R[] rights) {
135            if(null != rights && null != lefts){
136                if( lefts.length != rights.length){
137                    throw new IllegalArgumentException("mismatched length between left and right array");
138                }
139                for(int i=0;i<lefts.length;++i){
140                    this.fromRight(lefts[i],rights[i]);
141                }
142            }
143            return lefts;
144        }
145        
146        @SuppressWarnings("unchecked")
147        @Override
148        public R[] toRight(L[] lefts) {
149            R[] rights = null;
150            if(null != lefts){
151                rights = (R[])java.lang.reflect.Array.newInstance(rightType,lefts.length) ;
152                for(int i=0;i<lefts.length;++i){
153                    rights[i] = toRight(lefts[i]);
154                }
155            }
156            return rights;
157        }
158
159        @SuppressWarnings("unchecked")
160        @Override
161        public L[] fromRight(R[] rights) {
162            L[] lefts = null;
163            if(null != rights){
164                lefts = (L[])java.lang.reflect.Array.newInstance(leftType,rights.length) ;
165                for(int i=0;i<rights.length;++i){
166                    lefts[i] = fromRight(rights[i]);
167                }
168            }
169            return lefts;
170        }
171
172        @Override
173        public List<R> toRight(Collection<L> beans) {
174            if(null==beans){
175                return null;
176            }
177            ArrayList<R> rights = new ArrayList<R>(beans.size());
178            for(L g:beans){
179                rights.add(this.toRight(g));
180            }
181            return rights;
182        }
183
184        @Override
185        public List<L> fromRight(Collection<R> beans) {
186            if(null==beans){
187                return null;
188            }
189            ArrayList<L> lefts = new ArrayList<L>(beans.size());
190            for(R n:beans){
191                lefts.add(this.fromRight(n));
192            }
193            return lefts;
194        }
195
196        @Override
197        public List<R> toRight(List<L> lefts, List<R> rights) {
198            if(null != lefts && null != rights){
199                if( lefts.size() != rights.size()){
200                    throw new IllegalArgumentException("mismatched length between left and right list");
201                }
202                for(int i=0;i<lefts.size();++i){
203                    this.toRight(lefts.get(i),rights.get(i));
204                }
205            }
206            return rights;
207        }
208
209        @Override
210        public List<L> fromRight(List<L> lefts, List<R> rights) {
211            if(null != rights && null != lefts){
212                if( lefts.size() != rights.size()){
213                    throw new IllegalArgumentException("mismatched length between left and right list");
214                }
215                for(int i=0;i<lefts.size();++i){
216                    this.fromRight(lefts.get(i),rights.get(i));
217                }
218            }
219            return lefts;
220        }
221
222        @Override
223        public List<R> toRight(List<L> lefts) {
224            List<R> rights = null;
225            if(null != lefts ){
226                rights  = new ArrayList<>();
227                for(L l:lefts){
228                    rights.add(toRight(l));
229                }
230            }
231            return rights;    
232        }
233
234        @Override
235        public List<L> fromRight(List<R> rights) {
236            List<L> lefts = null;
237            if(null != rights ){
238                lefts  = new ArrayList<>();
239                for(R r:rights){
240                    lefts.add(fromRight(r));
241                }
242            }
243            return lefts;            
244        }
245        @Override
246        public<V> Map<R,V> toRightKey(Map<L,V> lmap) {
247            if(null == lmap){
248                return null;
249            }
250            HashMap<R,V> rmap = new HashMap<R,V>(16);
251            for(Entry<L, V> entry:lmap.entrySet()){
252                rmap.put(this.toRight(entry.getKey()),entry.getValue());
253            }
254            return rmap;
255        }
256        @Override
257        public<K> Map<K,R> toRightValue(Map<K,L> lmap) {
258            if(null == lmap){
259                return null;
260            }
261            HashMap<K, R> rmap = new HashMap<K, R>(16);
262            for(Entry<K, L> entry:lmap.entrySet()){
263                rmap.put(entry.getKey(), this.toRight(entry.getValue()));
264            }
265            return rmap;
266        }
267        @Override
268        public<V> Map<L,V> fromRightKey(Map<R,V> rmap) {
269            if(null == rmap){
270                return null;
271            }
272            HashMap<L,V> lmap = new HashMap<L,V>(16);
273            for(Entry<R, V> entry:rmap.entrySet()){
274                lmap.put(this.fromRight(entry.getKey()),entry.getValue());
275            }
276            return lmap;
277        }
278        @Override
279        public<K> Map<K,L> fromRightValue(Map<K,R> rmap) {
280            if(null == rmap){
281                return null;
282            }
283            HashMap<K, L> lmap = new HashMap<K, L>(16);
284            for(Entry<K, R> entry:rmap.entrySet()){
285                lmap.put(entry.getKey(), this.fromRight(entry.getValue()));
286            }
287            return lmap;
288        }
289        @Override
290        public Map<R,R> toRight(Map<L,L> lmap) {
291            if(null == lmap){
292                return null;
293            }
294            HashMap<R,R> rmap = new HashMap<R,R>(16);
295            for(Entry<L, L> entry:lmap.entrySet()){
296                rmap.put(this.toRight(entry.getKey()),this.toRight(entry.getValue()));
297            }
298            return rmap;
299        }
300        @Override
301        public Map<L,L> fromRight(Map<R,R> rmap) {
302            if(null == rmap){
303                return null;
304            }
305            HashMap<L,L> lmap = new HashMap<L,L>(16);
306            for(Entry<R, R> entry:rmap.entrySet()){
307                lmap.put(this.fromRight(entry.getKey()),this.fromRight(entry.getValue()));
308            }
309            return lmap;
310        }
311    }
312
313    /**
314     * copy right TO left
315     * @param left
316     * @param right
317     * @return left,or new instance if left is null
318     */
319    public L fromRight(L left, R right);
320    
321    /**
322     * copy left TO right
323     * @param left
324     * @param right
325     * @return right,or new instance if right is null
326     */
327    public R toRight(L left, R right);
328    /**
329     * return an new instance converted from R bean
330     * @param bean
331     * @return L bean
332     */
333    public L fromRight(R bean);
334    /**
335     * return an new instance converted from L bean
336     * @param bean
337     * @return R bean
338     */
339    public R toRight( L bean);
340    /**
341     * copy rights TO lefts
342     * @param lefts
343     * @param rights
344     * @return lefts,or new array if lefts is null
345     */
346    public L[] fromRight(L[] lefts,R[] rights);
347    /**
348     * copy lefts TO rights
349     * @param lefts
350     * @param rights
351     * @return rights,or new array if rights is null
352     */
353    public R[] toRight(L[] lefts,R[] rights);
354    /**
355     * return an new array converted from R beans
356     * @param beans
357     * @return L bean array
358     */
359    public L[] fromRight(R[] beans);
360    /**
361     * an new array converted from L beans
362     * @param beans
363     * @return R bean array
364     */
365    public R[] toRight(L[] beans);
366    /**
367     * copy rights TO lefts
368     * @param lefts
369     * @param rights
370     * @return lefts,or new array if lefts is null
371     */
372    public List<L> fromRight(List<L> lefts,List<R> rights);
373    /**
374     * copy lefts TO rights
375     * @param lefts
376     * @param rights
377     * @return rights,or new array if rights is null
378     */
379    public List<R> toRight(List<L> lefts,List<R> rights);
380    /**
381     * return an new list converted from R beans
382     * @param beans
383     * @return L bean list
384     */
385    public List<L> fromRight(List<R> beans);
386    /**
387     * return an new list converted from L beans
388     * @param beans
389     * @return R bean list
390     */
391    public List<R> toRight(List<L> beans);
392    /**
393     * return an new list converted from R beans
394     * @param beans
395     * @return L bean list
396     */
397    public List<L> fromRight(Collection<R> beans);
398    /**
399     * an new list converted from L beans
400     * @param beans
401     * @return R bean list
402     */
403    public List<R> toRight(Collection<L> beans);
404    
405    /**
406     * return an new map with R key converted from map with L key
407     * @param lmap
408     * @return Map with R key
409     */
410    public <V> Map<R,V> toRightKey(Map<L,V> lmap);
411    /**
412     * return an new map with R value converted from map with L value
413     * @param lmap
414     * @return Map with R value
415     */
416    public <K> Map<K,R> toRightValue(Map<K,L> lmap);
417    /**
418     * return an new map with L key converted from map with R key
419     * @param rmap
420     * @return Map with L key
421     */
422    public <V> Map<L,V> fromRightKey(Map<R,V> rmap);
423    /**
424     * return an new map with L value converted from map with R value
425     * @param rmap
426     * @return Map with L value
427     */
428    public <K> Map<K,L> fromRightValue(Map<K,R> rmap);
429    /**
430     * an new map with R key and  R value converted from map with L key and L value
431     * @param lmap
432     * @return Map with R key and value
433     */
434    public Map<R,R> toRight(Map<L,L> lmap);
435    /**
436     * return an new map with L key and  L value converted from map with R key and R value
437     * @param rmap
438     * @return Map with L key and value
439     */
440    public Map<L,L> fromRight(Map<R,R> rmap);
441}