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: bean.converter.utils.java.vm 007// ______________________________________________________ 008package net.gdface.facelog.db; 009import java.io.PrintWriter; 010import java.io.StringWriter; 011import java.lang.reflect.Method; 012import java.nio.ByteBuffer; 013import java.util.Map; 014import java.util.ArrayList; 015import java.util.Arrays; 016import java.util.Hashtable; 017import java.util.List; 018 019import net.gdface.facelog.db.IBeanConverter; 020 021import net.gdface.facelog.db.DeviceBean; 022import net.gdface.facelog.db.DeviceGroupBean; 023import net.gdface.facelog.db.FaceBean; 024import net.gdface.facelog.db.FeatureBean; 025import net.gdface.facelog.db.ImageBean; 026import net.gdface.facelog.db.LogBean; 027import net.gdface.facelog.db.PermitBean; 028import net.gdface.facelog.db.PersonBean; 029import net.gdface.facelog.db.PersonGroupBean; 030import net.gdface.facelog.db.StoreBean; 031import net.gdface.facelog.db.LogLightBean; 032 033/** 034 * generic type converter classes of {@link IBeanConverter} implementation for fl_device,fl_device_group,fl_face,fl_feature,fl_image,fl_log,fl_permit,fl_person,fl_person_group,fl_store,fl_log_light<br> 035 * @author guyadong 036 * 037 */ 038public class BeanConverterUtils implements Constant { 039 public static final String GET_INITIALIZED = "getInitialized"; 040 public static final String SET_INITIALIZED = "setInitialized"; 041 public static final String GET_MODIFIED = "getModified"; 042 public static final String SET_MODIFIED = "setModified"; 043 public static final String SET_NEW = "setNew"; 044 public static final String IS_NEW = "isNew"; 045 private static class NullCastPrimitiveException extends ClassCastException { 046 private static final long serialVersionUID = 1L; 047 NullCastPrimitiveException(String message) { 048 super(message); 049 } 050 } 051 private BeanConverterUtils(){} 052 /** 053 * 返回buffer中所有字节(position~limit),不改变buffer状态 054 * @param buffer 055 * @return 056 */ 057 private static final byte[] getBytesInBuffer(ByteBuffer buffer){ 058 int pos = buffer.position(); 059 try{ 060 byte[] bytes = new byte[buffer.remaining()]; 061 buffer.get(bytes); 062 return bytes; 063 }finally{ 064 buffer.position(pos); 065 } 066 } 067 private static final List<Long> toList(long[] array) { 068 ArrayList<Long> result = new ArrayList<Long>(array.length); 069 for (int i = 0; i < array.length; i++) { 070 result.add(new Long(array[i])); 071 } 072 return result; 073 } 074 private static final long[] toPrimitive(List<Long> list) { 075 long[] dst = new long[list.size()]; 076 Long element; 077 for (int i = 0; i < dst.length; i++) { 078 if(null == (element = list.get(i))){ 079 throw new IllegalArgumentException("can't cast List<Long> to long[] because of null element"); 080 } 081 dst[i] = element.longValue(); 082 } 083 return dst; 084 } 085 /** 086 * {@code source}转为{@code type}指定的类型 087 * @param type destination type 088 * @param source source object 089 * @return 090 */ 091 @SuppressWarnings({ "unchecked" }) 092 private static final <T> T cast(Class<T> type,Object source){ 093 try{ 094 if(null ==source && type.isPrimitive()){ 095 throw new NullCastPrimitiveException(String.format("can't convert null to primitive type %s",type.getSimpleName())); 096 } 097 return (T) source; 098 }catch(ClassCastException cce){ 099 // long[] -> List 100 if(List.class.isAssignableFrom(type) && null != source && source instanceof long[]){ 101 return (T) toList((long[]) source); 102 } 103 // List -> long[] 104 if(long[].class == type && null != source && source instanceof List){ 105 return (T) toPrimitive( (List<Long>) source); 106 } 107 // Long -> Date 108 if(java.util.Date.class.isAssignableFrom(type) && null != source && source instanceof Long){ 109 try { 110 // call constructor,such as java.util.Date#Date(long), java.sql.Time.Time(long) 111 return type.getConstructor(long.class).newInstance(source); 112 } catch (Exception e) { 113 StringWriter writer = new StringWriter(); 114 e.printStackTrace(new PrintWriter(writer)); 115 throw new ClassCastException(writer.toString()); 116 } 117 } 118 // Date -> Long,long 119 if( long.class == type || Long.class == type){ 120 if(null != source && source instanceof java.util.Date){ 121 Long time = ((java.util.Date)source).getTime(); 122 return (T)time; 123 } 124 } 125 // byte[] -> ByteBuffer 126 if(ByteBuffer.class == type && null != source && source instanceof byte[]){ 127 return (T) ByteBuffer.wrap((byte[]) source); 128 } 129 // ByteBuffer -> byte[] 130 if(byte[].class == type && null != source && source instanceof ByteBuffer){ 131 return (T) getBytesInBuffer((ByteBuffer) source); 132 } 133 throw cce; 134 } 135 } 136 private static final boolean bitCheck(int index,int...bits){ 137 return 0 != (bits[index>>STATE_BIT_SHIFT]&(1<<(index&0x1f))); 138 } 139 private static final int[] bitOR(int index,int... bits){ 140 bits[index>>STATE_BIT_SHIFT] |= (1<<(index&0x1f)); 141 return bits; 142 } 143 /** 144 * implementation of {@link IBeanConverter} by reflect<br> 145 * generic type converter between {@link DeviceBean} and R_DEVICE <br> 146 * @author guyadong 147 * @param <R_DEVICE> right type 148 * 149 */ 150 public static class DeviceBeanConverter<R_DEVICE> extends IBeanConverter.AbstractHandle<DeviceBean,R_DEVICE>{ 151 static enum Column{ 152 /** column method info */ 153 id("getId","setId"), 154 groupId("getGroupId","setGroupId"), 155 name("getName","setName"), 156 productName("getProductName","setProductName"), 157 model("getModel","setModel"), 158 vendor("getVendor","setVendor"), 159 manufacturer("getManufacturer","setManufacturer"), 160 madeDate("getMadeDate","setMadeDate"), 161 version("getVersion","setVersion"), 162 usedSdks("getUsedSdks","setUsedSdks"), 163 serialNo("getSerialNo","setSerialNo"), 164 mac("getMac","setMac"), 165 direction("getDirection","setDirection"), 166 remark("getRemark","setRemark"), 167 extBin("getExtBin","setExtBin"), 168 extTxt("getExtTxt","setExtTxt"), 169 createTime("getCreateTime","setCreateTime"), 170 updateTime("getUpdateTime","setUpdateTime"); 171 final String getter; 172 final String setter; 173 Column(String getter,String setter){ 174 this.getter = setter; 175 this.setter = setter; 176 } 177 } 178 private final Map<String,Method> methods = new Hashtable<String,Method>(); 179 private final Map<String,Integer> rightIndexs = new Hashtable<String,Integer>(); 180 private final Map<String, Class<?>> setterParams = new Hashtable<String,Class<?>>(); 181 182 private boolean bitCheck(String name,int...bits){ 183 Integer id = rightIndexs.get(name); 184 return (null == id)?false:BeanConverterUtils.bitCheck(id.intValue(),bits); 185 } 186 private int[] bitOR(String name,int... bits){ 187 return BeanConverterUtils.bitOR(rightIndexs.get(name),bits); 188 } 189 private void getGetter(String name){ 190 try{ 191 methods.put(name,rightType.getMethod(name)); 192 }catch(NoSuchMethodException e){} 193 } 194 private void getSetter(String name, Class<?>...types) throws NoSuchMethodException{ 195 for(Class<?>paramType:types){ 196 try{ 197 methods.put(name,rightType.getMethod(name,paramType)); 198 setterParams.put(name, paramType); 199 return; 200 }catch(NoSuchMethodException e){ 201 continue; 202 } 203 } 204 throw new NoSuchMethodException(); 205 } 206 private void getSetterNoThrow(String name, Class<?>...types){ 207 try{ 208 getSetter(name,types); 209 }catch(NoSuchMethodException e){} 210 } 211 /** 212 * usage: <pre>new DeviceBeanConverter<Model>(javaFields){};</pre> 213 * @param javaFields a comma splice string,including all field name of R_DEVICE,<br> 214 * if null or empty, use default string:{@link Constant#FL_DEVICE_JAVA_FIELDS} 215 */ 216 public DeviceBeanConverter(String javaFields){ 217 super(); 218 init(javaFields); 219 } 220 /** @see #DeviceBeanConverter(String) */ 221 public DeviceBeanConverter(){ 222 this(null); 223 } 224 /** 225 * constructor 226 * @param leftClass 227 * @param rightClass 228 * @param javaFields see also {@link #DeviceBeanConverter(String)} 229 */ 230 public DeviceBeanConverter (Class<DeviceBean> leftClass, Class<R_DEVICE> rightClass,String javaFields){ 231 super(leftClass,rightClass); 232 init(javaFields); 233 } 234 /** @see #DeviceBeanConverter(Class,Class,String) */ 235 public DeviceBeanConverter (Class<DeviceBean> leftClass, Class<R_DEVICE> rightClass){ 236 this(leftClass,rightClass,null); 237 } 238 private void init(String javaFields){ 239 if(null == javaFields || javaFields.isEmpty()){ 240 javaFields = FL_DEVICE_JAVA_FIELDS; 241 } 242 String []rightFields = javaFields.split(","); 243 for(int i = 0 ; i < rightFields.length; ++i){ 244 String field = rightFields[i].trim(); 245 if(!field.matches("\\w+")){ 246 throw new IllegalArgumentException("invalid 'javaFields':" + javaFields); 247 } 248 rightIndexs.put(field,i); 249 } 250 try{ 251 methods.put(IS_NEW,rightType.getMethod(IS_NEW)); 252 methods.put(GET_INITIALIZED,rightType.getMethod(GET_INITIALIZED)); 253 getSetter(SET_NEW,boolean.class); 254 if(rightIndexs.size() > STATE_BIT_NUM){ 255 getSetter(SET_INITIALIZED,int[].class,List.class); 256 }else{ 257 getSetter(SET_INITIALIZED,int.class); 258 } 259 getGetter(GET_MODIFIED); 260 if(rightIndexs.size() > STATE_BIT_NUM){ 261 getSetter(SET_MODIFIED,int[].class,List.class); 262 }else{ 263 getSetter(SET_MODIFIED,int.class); 264 } 265 }catch(NoSuchMethodException e){ 266 throw new RuntimeException(e); 267 } 268 269 getGetter(Column.id.getter); 270 getSetterNoThrow(Column.id.setter,Integer.class,int.class); 271 getGetter(Column.groupId.getter); 272 getSetterNoThrow(Column.groupId.setter,Integer.class,int.class); 273 getGetter(Column.name.getter); 274 getSetterNoThrow(Column.name.setter,String.class); 275 getGetter(Column.productName.getter); 276 getSetterNoThrow(Column.productName.setter,String.class); 277 getGetter(Column.model.getter); 278 getSetterNoThrow(Column.model.setter,String.class); 279 getGetter(Column.vendor.getter); 280 getSetterNoThrow(Column.vendor.setter,String.class); 281 getGetter(Column.manufacturer.getter); 282 getSetterNoThrow(Column.manufacturer.setter,String.class); 283 getGetter(Column.madeDate.getter); 284 getSetterNoThrow(Column.madeDate.setter,java.util.Date.class,Long.class,long.class); 285 getGetter(Column.version.getter); 286 getSetterNoThrow(Column.version.setter,String.class); 287 getGetter(Column.usedSdks.getter); 288 getSetterNoThrow(Column.usedSdks.setter,String.class); 289 getGetter(Column.serialNo.getter); 290 getSetterNoThrow(Column.serialNo.setter,String.class); 291 getGetter(Column.mac.getter); 292 getSetterNoThrow(Column.mac.setter,String.class); 293 getGetter(Column.direction.getter); 294 getSetterNoThrow(Column.direction.setter,Integer.class,int.class); 295 getGetter(Column.remark.getter); 296 getSetterNoThrow(Column.remark.setter,String.class); 297 getGetter(Column.extBin.getter); 298 getSetterNoThrow(Column.extBin.setter,java.nio.ByteBuffer.class,byte[].class); 299 getGetter(Column.extTxt.getter); 300 getSetterNoThrow(Column.extTxt.setter,String.class); 301 getGetter(Column.createTime.getter); 302 getSetterNoThrow(Column.createTime.setter,java.util.Date.class,Long.class,long.class); 303 getGetter(Column.updateTime.getter); 304 getSetterNoThrow(Column.updateTime.setter,java.util.Date.class,Long.class,long.class); 305 } 306 @Override 307 protected void doFromRight(DeviceBean left, R_DEVICE right) { 308 try{ 309 Method getterMethod; 310 left.resetIsModified(); 311 int selfModified = 0; 312 int[] initialized; 313 int[] modified; 314 if(rightIndexs.size() > STATE_BIT_NUM){ 315 initialized = (int[])methods.get(GET_INITIALIZED).invoke(right); 316 modified = (int[])methods.get(GET_MODIFIED).invoke(right); 317 }else{ 318 initialized = new int[]{(Integer)methods.get(GET_INITIALIZED).invoke(right)}; 319 modified = new int[]{(Integer)methods.get(GET_MODIFIED).invoke(right)}; 320 } 321 if( bitCheck(Column.id.name(),initialized) && (null != (getterMethod = methods.get(Column.id.getter)))){ 322 left.setId(cast(Integer.class,getterMethod.invoke(right))); 323 if(bitCheck(Column.id.name(),modified)){ 324 selfModified |= FL_DEVICE_ID_ID_MASK; 325 } 326 } 327 if( bitCheck(Column.groupId.name(),initialized) && (null != (getterMethod = methods.get(Column.groupId.getter)))){ 328 left.setGroupId(cast(Integer.class,getterMethod.invoke(right))); 329 if(bitCheck(Column.groupId.name(),modified)){ 330 selfModified |= FL_DEVICE_ID_GROUP_ID_MASK; 331 } 332 } 333 if( bitCheck(Column.name.name(),initialized) && (null != (getterMethod = methods.get(Column.name.getter)))){ 334 left.setName(cast(String.class,getterMethod.invoke(right))); 335 if(bitCheck(Column.name.name(),modified)){ 336 selfModified |= FL_DEVICE_ID_NAME_MASK; 337 } 338 } 339 if( bitCheck(Column.productName.name(),initialized) && (null != (getterMethod = methods.get(Column.productName.getter)))){ 340 left.setProductName(cast(String.class,getterMethod.invoke(right))); 341 if(bitCheck(Column.productName.name(),modified)){ 342 selfModified |= FL_DEVICE_ID_PRODUCT_NAME_MASK; 343 } 344 } 345 if( bitCheck(Column.model.name(),initialized) && (null != (getterMethod = methods.get(Column.model.getter)))){ 346 left.setModel(cast(String.class,getterMethod.invoke(right))); 347 if(bitCheck(Column.model.name(),modified)){ 348 selfModified |= FL_DEVICE_ID_MODEL_MASK; 349 } 350 } 351 if( bitCheck(Column.vendor.name(),initialized) && (null != (getterMethod = methods.get(Column.vendor.getter)))){ 352 left.setVendor(cast(String.class,getterMethod.invoke(right))); 353 if(bitCheck(Column.vendor.name(),modified)){ 354 selfModified |= FL_DEVICE_ID_VENDOR_MASK; 355 } 356 } 357 if( bitCheck(Column.manufacturer.name(),initialized) && (null != (getterMethod = methods.get(Column.manufacturer.getter)))){ 358 left.setManufacturer(cast(String.class,getterMethod.invoke(right))); 359 if(bitCheck(Column.manufacturer.name(),modified)){ 360 selfModified |= FL_DEVICE_ID_MANUFACTURER_MASK; 361 } 362 } 363 if( bitCheck(Column.madeDate.name(),initialized) && (null != (getterMethod = methods.get(Column.madeDate.getter)))){ 364 left.setMadeDate(cast(java.util.Date.class,getterMethod.invoke(right))); 365 if(bitCheck(Column.madeDate.name(),modified)){ 366 selfModified |= FL_DEVICE_ID_MADE_DATE_MASK; 367 } 368 } 369 if( bitCheck(Column.version.name(),initialized) && (null != (getterMethod = methods.get(Column.version.getter)))){ 370 left.setVersion(cast(String.class,getterMethod.invoke(right))); 371 if(bitCheck(Column.version.name(),modified)){ 372 selfModified |= FL_DEVICE_ID_VERSION_MASK; 373 } 374 } 375 if( bitCheck(Column.usedSdks.name(),initialized) && (null != (getterMethod = methods.get(Column.usedSdks.getter)))){ 376 left.setUsedSdks(cast(String.class,getterMethod.invoke(right))); 377 if(bitCheck(Column.usedSdks.name(),modified)){ 378 selfModified |= FL_DEVICE_ID_USED_SDKS_MASK; 379 } 380 } 381 if( bitCheck(Column.serialNo.name(),initialized) && (null != (getterMethod = methods.get(Column.serialNo.getter)))){ 382 left.setSerialNo(cast(String.class,getterMethod.invoke(right))); 383 if(bitCheck(Column.serialNo.name(),modified)){ 384 selfModified |= FL_DEVICE_ID_SERIAL_NO_MASK; 385 } 386 } 387 if( bitCheck(Column.mac.name(),initialized) && (null != (getterMethod = methods.get(Column.mac.getter)))){ 388 left.setMac(cast(String.class,getterMethod.invoke(right))); 389 if(bitCheck(Column.mac.name(),modified)){ 390 selfModified |= FL_DEVICE_ID_MAC_MASK; 391 } 392 } 393 if( bitCheck(Column.direction.name(),initialized) && (null != (getterMethod = methods.get(Column.direction.getter)))){ 394 left.setDirection(cast(Integer.class,getterMethod.invoke(right))); 395 if(bitCheck(Column.direction.name(),modified)){ 396 selfModified |= FL_DEVICE_ID_DIRECTION_MASK; 397 } 398 } 399 if( bitCheck(Column.remark.name(),initialized) && (null != (getterMethod = methods.get(Column.remark.getter)))){ 400 left.setRemark(cast(String.class,getterMethod.invoke(right))); 401 if(bitCheck(Column.remark.name(),modified)){ 402 selfModified |= FL_DEVICE_ID_REMARK_MASK; 403 } 404 } 405 if( bitCheck(Column.extBin.name(),initialized) && (null != (getterMethod = methods.get(Column.extBin.getter)))){ 406 left.setExtBin(cast(java.nio.ByteBuffer.class,getterMethod.invoke(right))); 407 if(bitCheck(Column.extBin.name(),modified)){ 408 selfModified |= FL_DEVICE_ID_EXT_BIN_MASK; 409 } 410 } 411 if( bitCheck(Column.extTxt.name(),initialized) && (null != (getterMethod = methods.get(Column.extTxt.getter)))){ 412 left.setExtTxt(cast(String.class,getterMethod.invoke(right))); 413 if(bitCheck(Column.extTxt.name(),modified)){ 414 selfModified |= FL_DEVICE_ID_EXT_TXT_MASK; 415 } 416 } 417 if( bitCheck(Column.createTime.name(),initialized) && (null != (getterMethod = methods.get(Column.createTime.getter)))){ 418 left.setCreateTime(cast(java.util.Date.class,getterMethod.invoke(right))); 419 if(bitCheck(Column.createTime.name(),modified)){ 420 selfModified |= FL_DEVICE_ID_CREATE_TIME_MASK; 421 } 422 } 423 if( bitCheck(Column.updateTime.name(),initialized) && (null != (getterMethod = methods.get(Column.updateTime.getter)))){ 424 left.setUpdateTime(cast(java.util.Date.class,getterMethod.invoke(right))); 425 if(bitCheck(Column.updateTime.name(),modified)){ 426 selfModified |= FL_DEVICE_ID_UPDATE_TIME_MASK; 427 } 428 } 429 left.isNew((Boolean)methods.get(IS_NEW).invoke(right)); 430 left.setModified(selfModified); 431 }catch(RuntimeException e){ 432 throw e; 433 }catch(Exception e){ 434 throw new RuntimeException(e); 435 } 436 } 437 438 @Override 439 protected void doToRight(DeviceBean left, R_DEVICE right) { 440 try{ 441 Method setterMethod; 442 int[] initialized = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 443 int[] modified = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 444 Arrays.fill(initialized, 0); 445 Arrays.fill(modified, 0); 446 if(null != (setterMethod = methods.get(Column.id.setter)) && left.checkIdInitialized()){ 447 try{ 448 setterMethod.invoke(right,cast(setterParams.get(Column.id.setter),left.getId())); 449 bitOR(Column.id.name(),initialized); 450 if(left.checkIdModified()){ 451 bitOR(Column.id.name(),modified); 452 } 453 }catch(NullCastPrimitiveException e){} 454 } 455 if(null != (setterMethod = methods.get(Column.groupId.setter)) && left.checkGroupIdInitialized()){ 456 try{ 457 setterMethod.invoke(right,cast(setterParams.get(Column.groupId.setter),left.getGroupId())); 458 bitOR(Column.groupId.name(),initialized); 459 if(left.checkGroupIdModified()){ 460 bitOR(Column.groupId.name(),modified); 461 } 462 }catch(NullCastPrimitiveException e){} 463 } 464 if(null != (setterMethod = methods.get(Column.name.setter)) && left.checkNameInitialized()){ 465 try{ 466 setterMethod.invoke(right,cast(setterParams.get(Column.name.setter),left.getName())); 467 bitOR(Column.name.name(),initialized); 468 if(left.checkNameModified()){ 469 bitOR(Column.name.name(),modified); 470 } 471 }catch(NullCastPrimitiveException e){} 472 } 473 if(null != (setterMethod = methods.get(Column.productName.setter)) && left.checkProductNameInitialized()){ 474 try{ 475 setterMethod.invoke(right,cast(setterParams.get(Column.productName.setter),left.getProductName())); 476 bitOR(Column.productName.name(),initialized); 477 if(left.checkProductNameModified()){ 478 bitOR(Column.productName.name(),modified); 479 } 480 }catch(NullCastPrimitiveException e){} 481 } 482 if(null != (setterMethod = methods.get(Column.model.setter)) && left.checkModelInitialized()){ 483 try{ 484 setterMethod.invoke(right,cast(setterParams.get(Column.model.setter),left.getModel())); 485 bitOR(Column.model.name(),initialized); 486 if(left.checkModelModified()){ 487 bitOR(Column.model.name(),modified); 488 } 489 }catch(NullCastPrimitiveException e){} 490 } 491 if(null != (setterMethod = methods.get(Column.vendor.setter)) && left.checkVendorInitialized()){ 492 try{ 493 setterMethod.invoke(right,cast(setterParams.get(Column.vendor.setter),left.getVendor())); 494 bitOR(Column.vendor.name(),initialized); 495 if(left.checkVendorModified()){ 496 bitOR(Column.vendor.name(),modified); 497 } 498 }catch(NullCastPrimitiveException e){} 499 } 500 if(null != (setterMethod = methods.get(Column.manufacturer.setter)) && left.checkManufacturerInitialized()){ 501 try{ 502 setterMethod.invoke(right,cast(setterParams.get(Column.manufacturer.setter),left.getManufacturer())); 503 bitOR(Column.manufacturer.name(),initialized); 504 if(left.checkManufacturerModified()){ 505 bitOR(Column.manufacturer.name(),modified); 506 } 507 }catch(NullCastPrimitiveException e){} 508 } 509 if(null != (setterMethod = methods.get(Column.madeDate.setter)) && left.checkMadeDateInitialized()){ 510 try{ 511 setterMethod.invoke(right,cast(setterParams.get(Column.madeDate.setter),left.getMadeDate())); 512 bitOR(Column.madeDate.name(),initialized); 513 if(left.checkMadeDateModified()){ 514 bitOR(Column.madeDate.name(),modified); 515 } 516 }catch(NullCastPrimitiveException e){} 517 } 518 if(null != (setterMethod = methods.get(Column.version.setter)) && left.checkVersionInitialized()){ 519 try{ 520 setterMethod.invoke(right,cast(setterParams.get(Column.version.setter),left.getVersion())); 521 bitOR(Column.version.name(),initialized); 522 if(left.checkVersionModified()){ 523 bitOR(Column.version.name(),modified); 524 } 525 }catch(NullCastPrimitiveException e){} 526 } 527 if(null != (setterMethod = methods.get(Column.usedSdks.setter)) && left.checkUsedSdksInitialized()){ 528 try{ 529 setterMethod.invoke(right,cast(setterParams.get(Column.usedSdks.setter),left.getUsedSdks())); 530 bitOR(Column.usedSdks.name(),initialized); 531 if(left.checkUsedSdksModified()){ 532 bitOR(Column.usedSdks.name(),modified); 533 } 534 }catch(NullCastPrimitiveException e){} 535 } 536 if(null != (setterMethod = methods.get(Column.serialNo.setter)) && left.checkSerialNoInitialized()){ 537 try{ 538 setterMethod.invoke(right,cast(setterParams.get(Column.serialNo.setter),left.getSerialNo())); 539 bitOR(Column.serialNo.name(),initialized); 540 if(left.checkSerialNoModified()){ 541 bitOR(Column.serialNo.name(),modified); 542 } 543 }catch(NullCastPrimitiveException e){} 544 } 545 if(null != (setterMethod = methods.get(Column.mac.setter)) && left.checkMacInitialized()){ 546 try{ 547 setterMethod.invoke(right,cast(setterParams.get(Column.mac.setter),left.getMac())); 548 bitOR(Column.mac.name(),initialized); 549 if(left.checkMacModified()){ 550 bitOR(Column.mac.name(),modified); 551 } 552 }catch(NullCastPrimitiveException e){} 553 } 554 if(null != (setterMethod = methods.get(Column.direction.setter)) && left.checkDirectionInitialized()){ 555 try{ 556 setterMethod.invoke(right,cast(setterParams.get(Column.direction.setter),left.getDirection())); 557 bitOR(Column.direction.name(),initialized); 558 if(left.checkDirectionModified()){ 559 bitOR(Column.direction.name(),modified); 560 } 561 }catch(NullCastPrimitiveException e){} 562 } 563 if(null != (setterMethod = methods.get(Column.remark.setter)) && left.checkRemarkInitialized()){ 564 try{ 565 setterMethod.invoke(right,cast(setterParams.get(Column.remark.setter),left.getRemark())); 566 bitOR(Column.remark.name(),initialized); 567 if(left.checkRemarkModified()){ 568 bitOR(Column.remark.name(),modified); 569 } 570 }catch(NullCastPrimitiveException e){} 571 } 572 if(null != (setterMethod = methods.get(Column.extBin.setter)) && left.checkExtBinInitialized()){ 573 try{ 574 setterMethod.invoke(right,cast(setterParams.get(Column.extBin.setter),left.getExtBin())); 575 bitOR(Column.extBin.name(),initialized); 576 if(left.checkExtBinModified()){ 577 bitOR(Column.extBin.name(),modified); 578 } 579 }catch(NullCastPrimitiveException e){} 580 } 581 if(null != (setterMethod = methods.get(Column.extTxt.setter)) && left.checkExtTxtInitialized()){ 582 try{ 583 setterMethod.invoke(right,cast(setterParams.get(Column.extTxt.setter),left.getExtTxt())); 584 bitOR(Column.extTxt.name(),initialized); 585 if(left.checkExtTxtModified()){ 586 bitOR(Column.extTxt.name(),modified); 587 } 588 }catch(NullCastPrimitiveException e){} 589 } 590// IGNORE field fl_device.create_time , controlled by 'general.beanconverter.tonative.ignore' in properties file 591/* 592 if(null != (setterMethod = methods.get(Column.createTime.setter)) && left.checkCreateTimeInitialized()){ 593 try{ 594 setterMethod.invoke(right,cast(setterParams.get(Column.createTime.setter),left.getCreateTime())); 595 bitOR(Column.createTime.name(),initialized); 596 if(left.checkCreateTimeModified()){ 597 bitOR(Column.createTime.name(),modified); 598 } 599 }catch(NullCastPrimitiveException e){} 600 } 601*/ 602// IGNORE field fl_device.update_time , controlled by 'general.beanconverter.tonative.ignore' in properties file 603/* 604 if(null != (setterMethod = methods.get(Column.updateTime.setter)) && left.checkUpdateTimeInitialized()){ 605 try{ 606 setterMethod.invoke(right,cast(setterParams.get(Column.updateTime.setter),left.getUpdateTime())); 607 bitOR(Column.updateTime.name(),initialized); 608 if(left.checkUpdateTimeModified()){ 609 bitOR(Column.updateTime.name(),modified); 610 } 611 }catch(NullCastPrimitiveException e){} 612 } 613*/ 614 if(null != (setterMethod = methods.get(SET_MODIFIED))){ 615 if( initialized.length > 1){ 616 setterMethod.invoke(right,cast(setterParams.get(SET_MODIFIED),initialized)); 617 }else{ 618 setterMethod.invoke(right,initialized[0]); 619 } 620 } 621 methods.get(SET_NEW).invoke(right,left.isNew()); 622 if( initialized.length > 1){ 623 methods.get(SET_INITIALIZED).invoke(right,cast(setterParams.get(SET_INITIALIZED),initialized)); 624 methods.get(SET_MODIFIED).invoke(right,cast(setterParams.get(SET_MODIFIED),modified)); 625 }else{ 626 methods.get(SET_INITIALIZED).invoke(right,initialized[0]); 627 methods.get(SET_MODIFIED).invoke(right,modified[0]); 628 } 629 }catch(RuntimeException e){ 630 throw e; 631 }catch(Exception e){ 632 throw new RuntimeException(e); 633 } 634 } 635 }; 636 /** 637 * implementation of {@link IBeanConverter} by reflect<br> 638 * generic type converter between {@link DeviceGroupBean} and R_DEVICEGROUP <br> 639 * @author guyadong 640 * @param <R_DEVICEGROUP> right type 641 * 642 */ 643 public static class DeviceGroupBeanConverter<R_DEVICEGROUP> extends IBeanConverter.AbstractHandle<DeviceGroupBean,R_DEVICEGROUP>{ 644 static enum Column{ 645 /** column method info */ 646 id("getId","setId"), 647 name("getName","setName"), 648 leaf("getLeaf","setLeaf"), 649 parent("getParent","setParent"), 650 rootGroup("getRootGroup","setRootGroup"), 651 schedule("getSchedule","setSchedule"), 652 remark("getRemark","setRemark"), 653 extBin("getExtBin","setExtBin"), 654 extTxt("getExtTxt","setExtTxt"), 655 createTime("getCreateTime","setCreateTime"), 656 updateTime("getUpdateTime","setUpdateTime"); 657 final String getter; 658 final String setter; 659 Column(String getter,String setter){ 660 this.getter = setter; 661 this.setter = setter; 662 } 663 } 664 private final Map<String,Method> methods = new Hashtable<String,Method>(); 665 private final Map<String,Integer> rightIndexs = new Hashtable<String,Integer>(); 666 private final Map<String, Class<?>> setterParams = new Hashtable<String,Class<?>>(); 667 668 private boolean bitCheck(String name,int...bits){ 669 Integer id = rightIndexs.get(name); 670 return (null == id)?false:BeanConverterUtils.bitCheck(id.intValue(),bits); 671 } 672 private int[] bitOR(String name,int... bits){ 673 return BeanConverterUtils.bitOR(rightIndexs.get(name),bits); 674 } 675 private void getGetter(String name){ 676 try{ 677 methods.put(name,rightType.getMethod(name)); 678 }catch(NoSuchMethodException e){} 679 } 680 private void getSetter(String name, Class<?>...types) throws NoSuchMethodException{ 681 for(Class<?>paramType:types){ 682 try{ 683 methods.put(name,rightType.getMethod(name,paramType)); 684 setterParams.put(name, paramType); 685 return; 686 }catch(NoSuchMethodException e){ 687 continue; 688 } 689 } 690 throw new NoSuchMethodException(); 691 } 692 private void getSetterNoThrow(String name, Class<?>...types){ 693 try{ 694 getSetter(name,types); 695 }catch(NoSuchMethodException e){} 696 } 697 /** 698 * usage: <pre>new DeviceGroupBeanConverter<Model>(javaFields){};</pre> 699 * @param javaFields a comma splice string,including all field name of R_DEVICEGROUP,<br> 700 * if null or empty, use default string:{@link Constant#FL_DEVICE_GROUP_JAVA_FIELDS} 701 */ 702 public DeviceGroupBeanConverter(String javaFields){ 703 super(); 704 init(javaFields); 705 } 706 /** @see #DeviceGroupBeanConverter(String) */ 707 public DeviceGroupBeanConverter(){ 708 this(null); 709 } 710 /** 711 * constructor 712 * @param leftClass 713 * @param rightClass 714 * @param javaFields see also {@link #DeviceGroupBeanConverter(String)} 715 */ 716 public DeviceGroupBeanConverter (Class<DeviceGroupBean> leftClass, Class<R_DEVICEGROUP> rightClass,String javaFields){ 717 super(leftClass,rightClass); 718 init(javaFields); 719 } 720 /** @see #DeviceGroupBeanConverter(Class,Class,String) */ 721 public DeviceGroupBeanConverter (Class<DeviceGroupBean> leftClass, Class<R_DEVICEGROUP> rightClass){ 722 this(leftClass,rightClass,null); 723 } 724 private void init(String javaFields){ 725 if(null == javaFields || javaFields.isEmpty()){ 726 javaFields = FL_DEVICE_GROUP_JAVA_FIELDS; 727 } 728 String []rightFields = javaFields.split(","); 729 for(int i = 0 ; i < rightFields.length; ++i){ 730 String field = rightFields[i].trim(); 731 if(!field.matches("\\w+")){ 732 throw new IllegalArgumentException("invalid 'javaFields':" + javaFields); 733 } 734 rightIndexs.put(field,i); 735 } 736 try{ 737 methods.put(IS_NEW,rightType.getMethod(IS_NEW)); 738 methods.put(GET_INITIALIZED,rightType.getMethod(GET_INITIALIZED)); 739 getSetter(SET_NEW,boolean.class); 740 if(rightIndexs.size() > STATE_BIT_NUM){ 741 getSetter(SET_INITIALIZED,int[].class,List.class); 742 }else{ 743 getSetter(SET_INITIALIZED,int.class); 744 } 745 getGetter(GET_MODIFIED); 746 if(rightIndexs.size() > STATE_BIT_NUM){ 747 getSetter(SET_MODIFIED,int[].class,List.class); 748 }else{ 749 getSetter(SET_MODIFIED,int.class); 750 } 751 }catch(NoSuchMethodException e){ 752 throw new RuntimeException(e); 753 } 754 755 getGetter(Column.id.getter); 756 getSetterNoThrow(Column.id.setter,Integer.class,int.class); 757 getGetter(Column.name.getter); 758 getSetterNoThrow(Column.name.setter,String.class); 759 getGetter(Column.leaf.getter); 760 getSetterNoThrow(Column.leaf.setter,Integer.class,int.class); 761 getGetter(Column.parent.getter); 762 getSetterNoThrow(Column.parent.setter,Integer.class,int.class); 763 getGetter(Column.rootGroup.getter); 764 getSetterNoThrow(Column.rootGroup.setter,Integer.class,int.class); 765 getGetter(Column.schedule.getter); 766 getSetterNoThrow(Column.schedule.setter,String.class); 767 getGetter(Column.remark.getter); 768 getSetterNoThrow(Column.remark.setter,String.class); 769 getGetter(Column.extBin.getter); 770 getSetterNoThrow(Column.extBin.setter,java.nio.ByteBuffer.class,byte[].class); 771 getGetter(Column.extTxt.getter); 772 getSetterNoThrow(Column.extTxt.setter,String.class); 773 getGetter(Column.createTime.getter); 774 getSetterNoThrow(Column.createTime.setter,java.util.Date.class,Long.class,long.class); 775 getGetter(Column.updateTime.getter); 776 getSetterNoThrow(Column.updateTime.setter,java.util.Date.class,Long.class,long.class); 777 } 778 @Override 779 protected void doFromRight(DeviceGroupBean left, R_DEVICEGROUP right) { 780 try{ 781 Method getterMethod; 782 left.resetIsModified(); 783 int selfModified = 0; 784 int[] initialized; 785 int[] modified; 786 if(rightIndexs.size() > STATE_BIT_NUM){ 787 initialized = (int[])methods.get(GET_INITIALIZED).invoke(right); 788 modified = (int[])methods.get(GET_MODIFIED).invoke(right); 789 }else{ 790 initialized = new int[]{(Integer)methods.get(GET_INITIALIZED).invoke(right)}; 791 modified = new int[]{(Integer)methods.get(GET_MODIFIED).invoke(right)}; 792 } 793 if( bitCheck(Column.id.name(),initialized) && (null != (getterMethod = methods.get(Column.id.getter)))){ 794 left.setId(cast(Integer.class,getterMethod.invoke(right))); 795 if(bitCheck(Column.id.name(),modified)){ 796 selfModified |= FL_DEVICE_GROUP_ID_ID_MASK; 797 } 798 } 799 if( bitCheck(Column.name.name(),initialized) && (null != (getterMethod = methods.get(Column.name.getter)))){ 800 left.setName(cast(String.class,getterMethod.invoke(right))); 801 if(bitCheck(Column.name.name(),modified)){ 802 selfModified |= FL_DEVICE_GROUP_ID_NAME_MASK; 803 } 804 } 805 if( bitCheck(Column.leaf.name(),initialized) && (null != (getterMethod = methods.get(Column.leaf.getter)))){ 806 left.setLeaf(cast(Integer.class,getterMethod.invoke(right))); 807 if(bitCheck(Column.leaf.name(),modified)){ 808 selfModified |= FL_DEVICE_GROUP_ID_LEAF_MASK; 809 } 810 } 811 if( bitCheck(Column.parent.name(),initialized) && (null != (getterMethod = methods.get(Column.parent.getter)))){ 812 left.setParent(cast(Integer.class,getterMethod.invoke(right))); 813 if(bitCheck(Column.parent.name(),modified)){ 814 selfModified |= FL_DEVICE_GROUP_ID_PARENT_MASK; 815 } 816 } 817 if( bitCheck(Column.rootGroup.name(),initialized) && (null != (getterMethod = methods.get(Column.rootGroup.getter)))){ 818 left.setRootGroup(cast(Integer.class,getterMethod.invoke(right))); 819 if(bitCheck(Column.rootGroup.name(),modified)){ 820 selfModified |= FL_DEVICE_GROUP_ID_ROOT_GROUP_MASK; 821 } 822 } 823 if( bitCheck(Column.schedule.name(),initialized) && (null != (getterMethod = methods.get(Column.schedule.getter)))){ 824 left.setSchedule(cast(String.class,getterMethod.invoke(right))); 825 if(bitCheck(Column.schedule.name(),modified)){ 826 selfModified |= FL_DEVICE_GROUP_ID_SCHEDULE_MASK; 827 } 828 } 829 if( bitCheck(Column.remark.name(),initialized) && (null != (getterMethod = methods.get(Column.remark.getter)))){ 830 left.setRemark(cast(String.class,getterMethod.invoke(right))); 831 if(bitCheck(Column.remark.name(),modified)){ 832 selfModified |= FL_DEVICE_GROUP_ID_REMARK_MASK; 833 } 834 } 835 if( bitCheck(Column.extBin.name(),initialized) && (null != (getterMethod = methods.get(Column.extBin.getter)))){ 836 left.setExtBin(cast(java.nio.ByteBuffer.class,getterMethod.invoke(right))); 837 if(bitCheck(Column.extBin.name(),modified)){ 838 selfModified |= FL_DEVICE_GROUP_ID_EXT_BIN_MASK; 839 } 840 } 841 if( bitCheck(Column.extTxt.name(),initialized) && (null != (getterMethod = methods.get(Column.extTxt.getter)))){ 842 left.setExtTxt(cast(String.class,getterMethod.invoke(right))); 843 if(bitCheck(Column.extTxt.name(),modified)){ 844 selfModified |= FL_DEVICE_GROUP_ID_EXT_TXT_MASK; 845 } 846 } 847 if( bitCheck(Column.createTime.name(),initialized) && (null != (getterMethod = methods.get(Column.createTime.getter)))){ 848 left.setCreateTime(cast(java.util.Date.class,getterMethod.invoke(right))); 849 if(bitCheck(Column.createTime.name(),modified)){ 850 selfModified |= FL_DEVICE_GROUP_ID_CREATE_TIME_MASK; 851 } 852 } 853 if( bitCheck(Column.updateTime.name(),initialized) && (null != (getterMethod = methods.get(Column.updateTime.getter)))){ 854 left.setUpdateTime(cast(java.util.Date.class,getterMethod.invoke(right))); 855 if(bitCheck(Column.updateTime.name(),modified)){ 856 selfModified |= FL_DEVICE_GROUP_ID_UPDATE_TIME_MASK; 857 } 858 } 859 left.isNew((Boolean)methods.get(IS_NEW).invoke(right)); 860 left.setModified(selfModified); 861 }catch(RuntimeException e){ 862 throw e; 863 }catch(Exception e){ 864 throw new RuntimeException(e); 865 } 866 } 867 868 @Override 869 protected void doToRight(DeviceGroupBean left, R_DEVICEGROUP right) { 870 try{ 871 Method setterMethod; 872 int[] initialized = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 873 int[] modified = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 874 Arrays.fill(initialized, 0); 875 Arrays.fill(modified, 0); 876 if(null != (setterMethod = methods.get(Column.id.setter)) && left.checkIdInitialized()){ 877 try{ 878 setterMethod.invoke(right,cast(setterParams.get(Column.id.setter),left.getId())); 879 bitOR(Column.id.name(),initialized); 880 if(left.checkIdModified()){ 881 bitOR(Column.id.name(),modified); 882 } 883 }catch(NullCastPrimitiveException e){} 884 } 885 if(null != (setterMethod = methods.get(Column.name.setter)) && left.checkNameInitialized()){ 886 try{ 887 setterMethod.invoke(right,cast(setterParams.get(Column.name.setter),left.getName())); 888 bitOR(Column.name.name(),initialized); 889 if(left.checkNameModified()){ 890 bitOR(Column.name.name(),modified); 891 } 892 }catch(NullCastPrimitiveException e){} 893 } 894 if(null != (setterMethod = methods.get(Column.leaf.setter)) && left.checkLeafInitialized()){ 895 try{ 896 setterMethod.invoke(right,cast(setterParams.get(Column.leaf.setter),left.getLeaf())); 897 bitOR(Column.leaf.name(),initialized); 898 if(left.checkLeafModified()){ 899 bitOR(Column.leaf.name(),modified); 900 } 901 }catch(NullCastPrimitiveException e){} 902 } 903 if(null != (setterMethod = methods.get(Column.parent.setter)) && left.checkParentInitialized()){ 904 try{ 905 setterMethod.invoke(right,cast(setterParams.get(Column.parent.setter),left.getParent())); 906 bitOR(Column.parent.name(),initialized); 907 if(left.checkParentModified()){ 908 bitOR(Column.parent.name(),modified); 909 } 910 }catch(NullCastPrimitiveException e){} 911 } 912 if(null != (setterMethod = methods.get(Column.rootGroup.setter)) && left.checkRootGroupInitialized()){ 913 try{ 914 setterMethod.invoke(right,cast(setterParams.get(Column.rootGroup.setter),left.getRootGroup())); 915 bitOR(Column.rootGroup.name(),initialized); 916 if(left.checkRootGroupModified()){ 917 bitOR(Column.rootGroup.name(),modified); 918 } 919 }catch(NullCastPrimitiveException e){} 920 } 921 if(null != (setterMethod = methods.get(Column.schedule.setter)) && left.checkScheduleInitialized()){ 922 try{ 923 setterMethod.invoke(right,cast(setterParams.get(Column.schedule.setter),left.getSchedule())); 924 bitOR(Column.schedule.name(),initialized); 925 if(left.checkScheduleModified()){ 926 bitOR(Column.schedule.name(),modified); 927 } 928 }catch(NullCastPrimitiveException e){} 929 } 930 if(null != (setterMethod = methods.get(Column.remark.setter)) && left.checkRemarkInitialized()){ 931 try{ 932 setterMethod.invoke(right,cast(setterParams.get(Column.remark.setter),left.getRemark())); 933 bitOR(Column.remark.name(),initialized); 934 if(left.checkRemarkModified()){ 935 bitOR(Column.remark.name(),modified); 936 } 937 }catch(NullCastPrimitiveException e){} 938 } 939 if(null != (setterMethod = methods.get(Column.extBin.setter)) && left.checkExtBinInitialized()){ 940 try{ 941 setterMethod.invoke(right,cast(setterParams.get(Column.extBin.setter),left.getExtBin())); 942 bitOR(Column.extBin.name(),initialized); 943 if(left.checkExtBinModified()){ 944 bitOR(Column.extBin.name(),modified); 945 } 946 }catch(NullCastPrimitiveException e){} 947 } 948 if(null != (setterMethod = methods.get(Column.extTxt.setter)) && left.checkExtTxtInitialized()){ 949 try{ 950 setterMethod.invoke(right,cast(setterParams.get(Column.extTxt.setter),left.getExtTxt())); 951 bitOR(Column.extTxt.name(),initialized); 952 if(left.checkExtTxtModified()){ 953 bitOR(Column.extTxt.name(),modified); 954 } 955 }catch(NullCastPrimitiveException e){} 956 } 957// IGNORE field fl_device_group.create_time , controlled by 'general.beanconverter.tonative.ignore' in properties file 958/* 959 if(null != (setterMethod = methods.get(Column.createTime.setter)) && left.checkCreateTimeInitialized()){ 960 try{ 961 setterMethod.invoke(right,cast(setterParams.get(Column.createTime.setter),left.getCreateTime())); 962 bitOR(Column.createTime.name(),initialized); 963 if(left.checkCreateTimeModified()){ 964 bitOR(Column.createTime.name(),modified); 965 } 966 }catch(NullCastPrimitiveException e){} 967 } 968*/ 969// IGNORE field fl_device_group.update_time , controlled by 'general.beanconverter.tonative.ignore' in properties file 970/* 971 if(null != (setterMethod = methods.get(Column.updateTime.setter)) && left.checkUpdateTimeInitialized()){ 972 try{ 973 setterMethod.invoke(right,cast(setterParams.get(Column.updateTime.setter),left.getUpdateTime())); 974 bitOR(Column.updateTime.name(),initialized); 975 if(left.checkUpdateTimeModified()){ 976 bitOR(Column.updateTime.name(),modified); 977 } 978 }catch(NullCastPrimitiveException e){} 979 } 980*/ 981 if(null != (setterMethod = methods.get(SET_MODIFIED))){ 982 if( initialized.length > 1){ 983 setterMethod.invoke(right,cast(setterParams.get(SET_MODIFIED),initialized)); 984 }else{ 985 setterMethod.invoke(right,initialized[0]); 986 } 987 } 988 methods.get(SET_NEW).invoke(right,left.isNew()); 989 if( initialized.length > 1){ 990 methods.get(SET_INITIALIZED).invoke(right,cast(setterParams.get(SET_INITIALIZED),initialized)); 991 methods.get(SET_MODIFIED).invoke(right,cast(setterParams.get(SET_MODIFIED),modified)); 992 }else{ 993 methods.get(SET_INITIALIZED).invoke(right,initialized[0]); 994 methods.get(SET_MODIFIED).invoke(right,modified[0]); 995 } 996 }catch(RuntimeException e){ 997 throw e; 998 }catch(Exception e){ 999 throw new RuntimeException(e); 1000 } 1001 } 1002 }; 1003 /** 1004 * implementation of {@link IBeanConverter} by reflect<br> 1005 * generic type converter between {@link FaceBean} and R_FACE <br> 1006 * @author guyadong 1007 * @param <R_FACE> right type 1008 * 1009 */ 1010 public static class FaceBeanConverter<R_FACE> extends IBeanConverter.AbstractHandle<FaceBean,R_FACE>{ 1011 static enum Column{ 1012 /** column method info */ 1013 id("getId","setId"), 1014 imageMd5("getImageMd5","setImageMd5"), 1015 faceLeft("getFaceLeft","setFaceLeft"), 1016 faceTop("getFaceTop","setFaceTop"), 1017 faceWidth("getFaceWidth","setFaceWidth"), 1018 faceHeight("getFaceHeight","setFaceHeight"), 1019 eyeLeftx("getEyeLeftx","setEyeLeftx"), 1020 eyeLefty("getEyeLefty","setEyeLefty"), 1021 eyeRightx("getEyeRightx","setEyeRightx"), 1022 eyeRighty("getEyeRighty","setEyeRighty"), 1023 mouthX("getMouthX","setMouthX"), 1024 mouthY("getMouthY","setMouthY"), 1025 noseX("getNoseX","setNoseX"), 1026 noseY("getNoseY","setNoseY"), 1027 angleYaw("getAngleYaw","setAngleYaw"), 1028 anglePitch("getAnglePitch","setAnglePitch"), 1029 angleRoll("getAngleRoll","setAngleRoll"), 1030 extInfo("getExtInfo","setExtInfo"), 1031 featureMd5("getFeatureMd5","setFeatureMd5"); 1032 final String getter; 1033 final String setter; 1034 Column(String getter,String setter){ 1035 this.getter = setter; 1036 this.setter = setter; 1037 } 1038 } 1039 private final Map<String,Method> methods = new Hashtable<String,Method>(); 1040 private final Map<String,Integer> rightIndexs = new Hashtable<String,Integer>(); 1041 private final Map<String, Class<?>> setterParams = new Hashtable<String,Class<?>>(); 1042 1043 private boolean bitCheck(String name,int...bits){ 1044 Integer id = rightIndexs.get(name); 1045 return (null == id)?false:BeanConverterUtils.bitCheck(id.intValue(),bits); 1046 } 1047 private int[] bitOR(String name,int... bits){ 1048 return BeanConverterUtils.bitOR(rightIndexs.get(name),bits); 1049 } 1050 private void getGetter(String name){ 1051 try{ 1052 methods.put(name,rightType.getMethod(name)); 1053 }catch(NoSuchMethodException e){} 1054 } 1055 private void getSetter(String name, Class<?>...types) throws NoSuchMethodException{ 1056 for(Class<?>paramType:types){ 1057 try{ 1058 methods.put(name,rightType.getMethod(name,paramType)); 1059 setterParams.put(name, paramType); 1060 return; 1061 }catch(NoSuchMethodException e){ 1062 continue; 1063 } 1064 } 1065 throw new NoSuchMethodException(); 1066 } 1067 private void getSetterNoThrow(String name, Class<?>...types){ 1068 try{ 1069 getSetter(name,types); 1070 }catch(NoSuchMethodException e){} 1071 } 1072 /** 1073 * usage: <pre>new FaceBeanConverter<Model>(javaFields){};</pre> 1074 * @param javaFields a comma splice string,including all field name of R_FACE,<br> 1075 * if null or empty, use default string:{@link Constant#FL_FACE_JAVA_FIELDS} 1076 */ 1077 public FaceBeanConverter(String javaFields){ 1078 super(); 1079 init(javaFields); 1080 } 1081 /** @see #FaceBeanConverter(String) */ 1082 public FaceBeanConverter(){ 1083 this(null); 1084 } 1085 /** 1086 * constructor 1087 * @param leftClass 1088 * @param rightClass 1089 * @param javaFields see also {@link #FaceBeanConverter(String)} 1090 */ 1091 public FaceBeanConverter (Class<FaceBean> leftClass, Class<R_FACE> rightClass,String javaFields){ 1092 super(leftClass,rightClass); 1093 init(javaFields); 1094 } 1095 /** @see #FaceBeanConverter(Class,Class,String) */ 1096 public FaceBeanConverter (Class<FaceBean> leftClass, Class<R_FACE> rightClass){ 1097 this(leftClass,rightClass,null); 1098 } 1099 private void init(String javaFields){ 1100 if(null == javaFields || javaFields.isEmpty()){ 1101 javaFields = FL_FACE_JAVA_FIELDS; 1102 } 1103 String []rightFields = javaFields.split(","); 1104 for(int i = 0 ; i < rightFields.length; ++i){ 1105 String field = rightFields[i].trim(); 1106 if(!field.matches("\\w+")){ 1107 throw new IllegalArgumentException("invalid 'javaFields':" + javaFields); 1108 } 1109 rightIndexs.put(field,i); 1110 } 1111 try{ 1112 methods.put(IS_NEW,rightType.getMethod(IS_NEW)); 1113 methods.put(GET_INITIALIZED,rightType.getMethod(GET_INITIALIZED)); 1114 getSetter(SET_NEW,boolean.class); 1115 if(rightIndexs.size() > STATE_BIT_NUM){ 1116 getSetter(SET_INITIALIZED,int[].class,List.class); 1117 }else{ 1118 getSetter(SET_INITIALIZED,int.class); 1119 } 1120 getGetter(GET_MODIFIED); 1121 if(rightIndexs.size() > STATE_BIT_NUM){ 1122 getSetter(SET_MODIFIED,int[].class,List.class); 1123 }else{ 1124 getSetter(SET_MODIFIED,int.class); 1125 } 1126 }catch(NoSuchMethodException e){ 1127 throw new RuntimeException(e); 1128 } 1129 1130 getGetter(Column.id.getter); 1131 getSetterNoThrow(Column.id.setter,Integer.class,int.class); 1132 getGetter(Column.imageMd5.getter); 1133 getSetterNoThrow(Column.imageMd5.setter,String.class); 1134 getGetter(Column.faceLeft.getter); 1135 getSetterNoThrow(Column.faceLeft.setter,Integer.class,int.class); 1136 getGetter(Column.faceTop.getter); 1137 getSetterNoThrow(Column.faceTop.setter,Integer.class,int.class); 1138 getGetter(Column.faceWidth.getter); 1139 getSetterNoThrow(Column.faceWidth.setter,Integer.class,int.class); 1140 getGetter(Column.faceHeight.getter); 1141 getSetterNoThrow(Column.faceHeight.setter,Integer.class,int.class); 1142 getGetter(Column.eyeLeftx.getter); 1143 getSetterNoThrow(Column.eyeLeftx.setter,Integer.class,int.class); 1144 getGetter(Column.eyeLefty.getter); 1145 getSetterNoThrow(Column.eyeLefty.setter,Integer.class,int.class); 1146 getGetter(Column.eyeRightx.getter); 1147 getSetterNoThrow(Column.eyeRightx.setter,Integer.class,int.class); 1148 getGetter(Column.eyeRighty.getter); 1149 getSetterNoThrow(Column.eyeRighty.setter,Integer.class,int.class); 1150 getGetter(Column.mouthX.getter); 1151 getSetterNoThrow(Column.mouthX.setter,Integer.class,int.class); 1152 getGetter(Column.mouthY.getter); 1153 getSetterNoThrow(Column.mouthY.setter,Integer.class,int.class); 1154 getGetter(Column.noseX.getter); 1155 getSetterNoThrow(Column.noseX.setter,Integer.class,int.class); 1156 getGetter(Column.noseY.getter); 1157 getSetterNoThrow(Column.noseY.setter,Integer.class,int.class); 1158 getGetter(Column.angleYaw.getter); 1159 getSetterNoThrow(Column.angleYaw.setter,Integer.class,int.class); 1160 getGetter(Column.anglePitch.getter); 1161 getSetterNoThrow(Column.anglePitch.setter,Integer.class,int.class); 1162 getGetter(Column.angleRoll.getter); 1163 getSetterNoThrow(Column.angleRoll.setter,Integer.class,int.class); 1164 getGetter(Column.extInfo.getter); 1165 getSetterNoThrow(Column.extInfo.setter,java.nio.ByteBuffer.class,byte[].class); 1166 getGetter(Column.featureMd5.getter); 1167 getSetterNoThrow(Column.featureMd5.setter,String.class); 1168 } 1169 @Override 1170 protected void doFromRight(FaceBean left, R_FACE right) { 1171 try{ 1172 Method getterMethod; 1173 left.resetIsModified(); 1174 int selfModified = 0; 1175 int[] initialized; 1176 int[] modified; 1177 if(rightIndexs.size() > STATE_BIT_NUM){ 1178 initialized = (int[])methods.get(GET_INITIALIZED).invoke(right); 1179 modified = (int[])methods.get(GET_MODIFIED).invoke(right); 1180 }else{ 1181 initialized = new int[]{(Integer)methods.get(GET_INITIALIZED).invoke(right)}; 1182 modified = new int[]{(Integer)methods.get(GET_MODIFIED).invoke(right)}; 1183 } 1184 if( bitCheck(Column.id.name(),initialized) && (null != (getterMethod = methods.get(Column.id.getter)))){ 1185 left.setId(cast(Integer.class,getterMethod.invoke(right))); 1186 if(bitCheck(Column.id.name(),modified)){ 1187 selfModified |= FL_FACE_ID_ID_MASK; 1188 } 1189 } 1190 if( bitCheck(Column.imageMd5.name(),initialized) && (null != (getterMethod = methods.get(Column.imageMd5.getter)))){ 1191 left.setImageMd5(cast(String.class,getterMethod.invoke(right))); 1192 if(bitCheck(Column.imageMd5.name(),modified)){ 1193 selfModified |= FL_FACE_ID_IMAGE_MD5_MASK; 1194 } 1195 } 1196 if( bitCheck(Column.faceLeft.name(),initialized) && (null != (getterMethod = methods.get(Column.faceLeft.getter)))){ 1197 left.setFaceLeft(cast(Integer.class,getterMethod.invoke(right))); 1198 if(bitCheck(Column.faceLeft.name(),modified)){ 1199 selfModified |= FL_FACE_ID_FACE_LEFT_MASK; 1200 } 1201 } 1202 if( bitCheck(Column.faceTop.name(),initialized) && (null != (getterMethod = methods.get(Column.faceTop.getter)))){ 1203 left.setFaceTop(cast(Integer.class,getterMethod.invoke(right))); 1204 if(bitCheck(Column.faceTop.name(),modified)){ 1205 selfModified |= FL_FACE_ID_FACE_TOP_MASK; 1206 } 1207 } 1208 if( bitCheck(Column.faceWidth.name(),initialized) && (null != (getterMethod = methods.get(Column.faceWidth.getter)))){ 1209 left.setFaceWidth(cast(Integer.class,getterMethod.invoke(right))); 1210 if(bitCheck(Column.faceWidth.name(),modified)){ 1211 selfModified |= FL_FACE_ID_FACE_WIDTH_MASK; 1212 } 1213 } 1214 if( bitCheck(Column.faceHeight.name(),initialized) && (null != (getterMethod = methods.get(Column.faceHeight.getter)))){ 1215 left.setFaceHeight(cast(Integer.class,getterMethod.invoke(right))); 1216 if(bitCheck(Column.faceHeight.name(),modified)){ 1217 selfModified |= FL_FACE_ID_FACE_HEIGHT_MASK; 1218 } 1219 } 1220 if( bitCheck(Column.eyeLeftx.name(),initialized) && (null != (getterMethod = methods.get(Column.eyeLeftx.getter)))){ 1221 left.setEyeLeftx(cast(Integer.class,getterMethod.invoke(right))); 1222 if(bitCheck(Column.eyeLeftx.name(),modified)){ 1223 selfModified |= FL_FACE_ID_EYE_LEFTX_MASK; 1224 } 1225 } 1226 if( bitCheck(Column.eyeLefty.name(),initialized) && (null != (getterMethod = methods.get(Column.eyeLefty.getter)))){ 1227 left.setEyeLefty(cast(Integer.class,getterMethod.invoke(right))); 1228 if(bitCheck(Column.eyeLefty.name(),modified)){ 1229 selfModified |= FL_FACE_ID_EYE_LEFTY_MASK; 1230 } 1231 } 1232 if( bitCheck(Column.eyeRightx.name(),initialized) && (null != (getterMethod = methods.get(Column.eyeRightx.getter)))){ 1233 left.setEyeRightx(cast(Integer.class,getterMethod.invoke(right))); 1234 if(bitCheck(Column.eyeRightx.name(),modified)){ 1235 selfModified |= FL_FACE_ID_EYE_RIGHTX_MASK; 1236 } 1237 } 1238 if( bitCheck(Column.eyeRighty.name(),initialized) && (null != (getterMethod = methods.get(Column.eyeRighty.getter)))){ 1239 left.setEyeRighty(cast(Integer.class,getterMethod.invoke(right))); 1240 if(bitCheck(Column.eyeRighty.name(),modified)){ 1241 selfModified |= FL_FACE_ID_EYE_RIGHTY_MASK; 1242 } 1243 } 1244 if( bitCheck(Column.mouthX.name(),initialized) && (null != (getterMethod = methods.get(Column.mouthX.getter)))){ 1245 left.setMouthX(cast(Integer.class,getterMethod.invoke(right))); 1246 if(bitCheck(Column.mouthX.name(),modified)){ 1247 selfModified |= FL_FACE_ID_MOUTH_X_MASK; 1248 } 1249 } 1250 if( bitCheck(Column.mouthY.name(),initialized) && (null != (getterMethod = methods.get(Column.mouthY.getter)))){ 1251 left.setMouthY(cast(Integer.class,getterMethod.invoke(right))); 1252 if(bitCheck(Column.mouthY.name(),modified)){ 1253 selfModified |= FL_FACE_ID_MOUTH_Y_MASK; 1254 } 1255 } 1256 if( bitCheck(Column.noseX.name(),initialized) && (null != (getterMethod = methods.get(Column.noseX.getter)))){ 1257 left.setNoseX(cast(Integer.class,getterMethod.invoke(right))); 1258 if(bitCheck(Column.noseX.name(),modified)){ 1259 selfModified |= FL_FACE_ID_NOSE_X_MASK; 1260 } 1261 } 1262 if( bitCheck(Column.noseY.name(),initialized) && (null != (getterMethod = methods.get(Column.noseY.getter)))){ 1263 left.setNoseY(cast(Integer.class,getterMethod.invoke(right))); 1264 if(bitCheck(Column.noseY.name(),modified)){ 1265 selfModified |= FL_FACE_ID_NOSE_Y_MASK; 1266 } 1267 } 1268 if( bitCheck(Column.angleYaw.name(),initialized) && (null != (getterMethod = methods.get(Column.angleYaw.getter)))){ 1269 left.setAngleYaw(cast(Integer.class,getterMethod.invoke(right))); 1270 if(bitCheck(Column.angleYaw.name(),modified)){ 1271 selfModified |= FL_FACE_ID_ANGLE_YAW_MASK; 1272 } 1273 } 1274 if( bitCheck(Column.anglePitch.name(),initialized) && (null != (getterMethod = methods.get(Column.anglePitch.getter)))){ 1275 left.setAnglePitch(cast(Integer.class,getterMethod.invoke(right))); 1276 if(bitCheck(Column.anglePitch.name(),modified)){ 1277 selfModified |= FL_FACE_ID_ANGLE_PITCH_MASK; 1278 } 1279 } 1280 if( bitCheck(Column.angleRoll.name(),initialized) && (null != (getterMethod = methods.get(Column.angleRoll.getter)))){ 1281 left.setAngleRoll(cast(Integer.class,getterMethod.invoke(right))); 1282 if(bitCheck(Column.angleRoll.name(),modified)){ 1283 selfModified |= FL_FACE_ID_ANGLE_ROLL_MASK; 1284 } 1285 } 1286 if( bitCheck(Column.extInfo.name(),initialized) && (null != (getterMethod = methods.get(Column.extInfo.getter)))){ 1287 left.setExtInfo(cast(java.nio.ByteBuffer.class,getterMethod.invoke(right))); 1288 if(bitCheck(Column.extInfo.name(),modified)){ 1289 selfModified |= FL_FACE_ID_EXT_INFO_MASK; 1290 } 1291 } 1292 if( bitCheck(Column.featureMd5.name(),initialized) && (null != (getterMethod = methods.get(Column.featureMd5.getter)))){ 1293 left.setFeatureMd5(cast(String.class,getterMethod.invoke(right))); 1294 if(bitCheck(Column.featureMd5.name(),modified)){ 1295 selfModified |= FL_FACE_ID_FEATURE_MD5_MASK; 1296 } 1297 } 1298 left.isNew((Boolean)methods.get(IS_NEW).invoke(right)); 1299 left.setModified(selfModified); 1300 }catch(RuntimeException e){ 1301 throw e; 1302 }catch(Exception e){ 1303 throw new RuntimeException(e); 1304 } 1305 } 1306 1307 @Override 1308 protected void doToRight(FaceBean left, R_FACE right) { 1309 try{ 1310 Method setterMethod; 1311 int[] initialized = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 1312 int[] modified = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 1313 Arrays.fill(initialized, 0); 1314 Arrays.fill(modified, 0); 1315 if(null != (setterMethod = methods.get(Column.id.setter)) && left.checkIdInitialized()){ 1316 try{ 1317 setterMethod.invoke(right,cast(setterParams.get(Column.id.setter),left.getId())); 1318 bitOR(Column.id.name(),initialized); 1319 if(left.checkIdModified()){ 1320 bitOR(Column.id.name(),modified); 1321 } 1322 }catch(NullCastPrimitiveException e){} 1323 } 1324 if(null != (setterMethod = methods.get(Column.imageMd5.setter)) && left.checkImageMd5Initialized()){ 1325 try{ 1326 setterMethod.invoke(right,cast(setterParams.get(Column.imageMd5.setter),left.getImageMd5())); 1327 bitOR(Column.imageMd5.name(),initialized); 1328 if(left.checkImageMd5Modified()){ 1329 bitOR(Column.imageMd5.name(),modified); 1330 } 1331 }catch(NullCastPrimitiveException e){} 1332 } 1333 if(null != (setterMethod = methods.get(Column.faceLeft.setter)) && left.checkFaceLeftInitialized()){ 1334 try{ 1335 setterMethod.invoke(right,cast(setterParams.get(Column.faceLeft.setter),left.getFaceLeft())); 1336 bitOR(Column.faceLeft.name(),initialized); 1337 if(left.checkFaceLeftModified()){ 1338 bitOR(Column.faceLeft.name(),modified); 1339 } 1340 }catch(NullCastPrimitiveException e){} 1341 } 1342 if(null != (setterMethod = methods.get(Column.faceTop.setter)) && left.checkFaceTopInitialized()){ 1343 try{ 1344 setterMethod.invoke(right,cast(setterParams.get(Column.faceTop.setter),left.getFaceTop())); 1345 bitOR(Column.faceTop.name(),initialized); 1346 if(left.checkFaceTopModified()){ 1347 bitOR(Column.faceTop.name(),modified); 1348 } 1349 }catch(NullCastPrimitiveException e){} 1350 } 1351 if(null != (setterMethod = methods.get(Column.faceWidth.setter)) && left.checkFaceWidthInitialized()){ 1352 try{ 1353 setterMethod.invoke(right,cast(setterParams.get(Column.faceWidth.setter),left.getFaceWidth())); 1354 bitOR(Column.faceWidth.name(),initialized); 1355 if(left.checkFaceWidthModified()){ 1356 bitOR(Column.faceWidth.name(),modified); 1357 } 1358 }catch(NullCastPrimitiveException e){} 1359 } 1360 if(null != (setterMethod = methods.get(Column.faceHeight.setter)) && left.checkFaceHeightInitialized()){ 1361 try{ 1362 setterMethod.invoke(right,cast(setterParams.get(Column.faceHeight.setter),left.getFaceHeight())); 1363 bitOR(Column.faceHeight.name(),initialized); 1364 if(left.checkFaceHeightModified()){ 1365 bitOR(Column.faceHeight.name(),modified); 1366 } 1367 }catch(NullCastPrimitiveException e){} 1368 } 1369 if(null != (setterMethod = methods.get(Column.eyeLeftx.setter)) && left.checkEyeLeftxInitialized()){ 1370 try{ 1371 setterMethod.invoke(right,cast(setterParams.get(Column.eyeLeftx.setter),left.getEyeLeftx())); 1372 bitOR(Column.eyeLeftx.name(),initialized); 1373 if(left.checkEyeLeftxModified()){ 1374 bitOR(Column.eyeLeftx.name(),modified); 1375 } 1376 }catch(NullCastPrimitiveException e){} 1377 } 1378 if(null != (setterMethod = methods.get(Column.eyeLefty.setter)) && left.checkEyeLeftyInitialized()){ 1379 try{ 1380 setterMethod.invoke(right,cast(setterParams.get(Column.eyeLefty.setter),left.getEyeLefty())); 1381 bitOR(Column.eyeLefty.name(),initialized); 1382 if(left.checkEyeLeftyModified()){ 1383 bitOR(Column.eyeLefty.name(),modified); 1384 } 1385 }catch(NullCastPrimitiveException e){} 1386 } 1387 if(null != (setterMethod = methods.get(Column.eyeRightx.setter)) && left.checkEyeRightxInitialized()){ 1388 try{ 1389 setterMethod.invoke(right,cast(setterParams.get(Column.eyeRightx.setter),left.getEyeRightx())); 1390 bitOR(Column.eyeRightx.name(),initialized); 1391 if(left.checkEyeRightxModified()){ 1392 bitOR(Column.eyeRightx.name(),modified); 1393 } 1394 }catch(NullCastPrimitiveException e){} 1395 } 1396 if(null != (setterMethod = methods.get(Column.eyeRighty.setter)) && left.checkEyeRightyInitialized()){ 1397 try{ 1398 setterMethod.invoke(right,cast(setterParams.get(Column.eyeRighty.setter),left.getEyeRighty())); 1399 bitOR(Column.eyeRighty.name(),initialized); 1400 if(left.checkEyeRightyModified()){ 1401 bitOR(Column.eyeRighty.name(),modified); 1402 } 1403 }catch(NullCastPrimitiveException e){} 1404 } 1405 if(null != (setterMethod = methods.get(Column.mouthX.setter)) && left.checkMouthXInitialized()){ 1406 try{ 1407 setterMethod.invoke(right,cast(setterParams.get(Column.mouthX.setter),left.getMouthX())); 1408 bitOR(Column.mouthX.name(),initialized); 1409 if(left.checkMouthXModified()){ 1410 bitOR(Column.mouthX.name(),modified); 1411 } 1412 }catch(NullCastPrimitiveException e){} 1413 } 1414 if(null != (setterMethod = methods.get(Column.mouthY.setter)) && left.checkMouthYInitialized()){ 1415 try{ 1416 setterMethod.invoke(right,cast(setterParams.get(Column.mouthY.setter),left.getMouthY())); 1417 bitOR(Column.mouthY.name(),initialized); 1418 if(left.checkMouthYModified()){ 1419 bitOR(Column.mouthY.name(),modified); 1420 } 1421 }catch(NullCastPrimitiveException e){} 1422 } 1423 if(null != (setterMethod = methods.get(Column.noseX.setter)) && left.checkNoseXInitialized()){ 1424 try{ 1425 setterMethod.invoke(right,cast(setterParams.get(Column.noseX.setter),left.getNoseX())); 1426 bitOR(Column.noseX.name(),initialized); 1427 if(left.checkNoseXModified()){ 1428 bitOR(Column.noseX.name(),modified); 1429 } 1430 }catch(NullCastPrimitiveException e){} 1431 } 1432 if(null != (setterMethod = methods.get(Column.noseY.setter)) && left.checkNoseYInitialized()){ 1433 try{ 1434 setterMethod.invoke(right,cast(setterParams.get(Column.noseY.setter),left.getNoseY())); 1435 bitOR(Column.noseY.name(),initialized); 1436 if(left.checkNoseYModified()){ 1437 bitOR(Column.noseY.name(),modified); 1438 } 1439 }catch(NullCastPrimitiveException e){} 1440 } 1441 if(null != (setterMethod = methods.get(Column.angleYaw.setter)) && left.checkAngleYawInitialized()){ 1442 try{ 1443 setterMethod.invoke(right,cast(setterParams.get(Column.angleYaw.setter),left.getAngleYaw())); 1444 bitOR(Column.angleYaw.name(),initialized); 1445 if(left.checkAngleYawModified()){ 1446 bitOR(Column.angleYaw.name(),modified); 1447 } 1448 }catch(NullCastPrimitiveException e){} 1449 } 1450 if(null != (setterMethod = methods.get(Column.anglePitch.setter)) && left.checkAnglePitchInitialized()){ 1451 try{ 1452 setterMethod.invoke(right,cast(setterParams.get(Column.anglePitch.setter),left.getAnglePitch())); 1453 bitOR(Column.anglePitch.name(),initialized); 1454 if(left.checkAnglePitchModified()){ 1455 bitOR(Column.anglePitch.name(),modified); 1456 } 1457 }catch(NullCastPrimitiveException e){} 1458 } 1459 if(null != (setterMethod = methods.get(Column.angleRoll.setter)) && left.checkAngleRollInitialized()){ 1460 try{ 1461 setterMethod.invoke(right,cast(setterParams.get(Column.angleRoll.setter),left.getAngleRoll())); 1462 bitOR(Column.angleRoll.name(),initialized); 1463 if(left.checkAngleRollModified()){ 1464 bitOR(Column.angleRoll.name(),modified); 1465 } 1466 }catch(NullCastPrimitiveException e){} 1467 } 1468 if(null != (setterMethod = methods.get(Column.extInfo.setter)) && left.checkExtInfoInitialized()){ 1469 try{ 1470 setterMethod.invoke(right,cast(setterParams.get(Column.extInfo.setter),left.getExtInfo())); 1471 bitOR(Column.extInfo.name(),initialized); 1472 if(left.checkExtInfoModified()){ 1473 bitOR(Column.extInfo.name(),modified); 1474 } 1475 }catch(NullCastPrimitiveException e){} 1476 } 1477 if(null != (setterMethod = methods.get(Column.featureMd5.setter)) && left.checkFeatureMd5Initialized()){ 1478 try{ 1479 setterMethod.invoke(right,cast(setterParams.get(Column.featureMd5.setter),left.getFeatureMd5())); 1480 bitOR(Column.featureMd5.name(),initialized); 1481 if(left.checkFeatureMd5Modified()){ 1482 bitOR(Column.featureMd5.name(),modified); 1483 } 1484 }catch(NullCastPrimitiveException e){} 1485 } 1486 if(null != (setterMethod = methods.get(SET_MODIFIED))){ 1487 if( initialized.length > 1){ 1488 setterMethod.invoke(right,cast(setterParams.get(SET_MODIFIED),initialized)); 1489 }else{ 1490 setterMethod.invoke(right,initialized[0]); 1491 } 1492 } 1493 methods.get(SET_NEW).invoke(right,left.isNew()); 1494 if( initialized.length > 1){ 1495 methods.get(SET_INITIALIZED).invoke(right,cast(setterParams.get(SET_INITIALIZED),initialized)); 1496 methods.get(SET_MODIFIED).invoke(right,cast(setterParams.get(SET_MODIFIED),modified)); 1497 }else{ 1498 methods.get(SET_INITIALIZED).invoke(right,initialized[0]); 1499 methods.get(SET_MODIFIED).invoke(right,modified[0]); 1500 } 1501 }catch(RuntimeException e){ 1502 throw e; 1503 }catch(Exception e){ 1504 throw new RuntimeException(e); 1505 } 1506 } 1507 }; 1508 /** 1509 * implementation of {@link IBeanConverter} by reflect<br> 1510 * generic type converter between {@link FeatureBean} and R_FEATURE <br> 1511 * @author guyadong 1512 * @param <R_FEATURE> right type 1513 * 1514 */ 1515 public static class FeatureBeanConverter<R_FEATURE> extends IBeanConverter.AbstractHandle<FeatureBean,R_FEATURE>{ 1516 static enum Column{ 1517 /** column method info */ 1518 md5("getMd5","setMd5"), 1519 version("getVersion","setVersion"), 1520 personId("getPersonId","setPersonId"), 1521 feature("getFeature","setFeature"), 1522 updateTime("getUpdateTime","setUpdateTime"); 1523 final String getter; 1524 final String setter; 1525 Column(String getter,String setter){ 1526 this.getter = setter; 1527 this.setter = setter; 1528 } 1529 } 1530 private final Map<String,Method> methods = new Hashtable<String,Method>(); 1531 private final Map<String,Integer> rightIndexs = new Hashtable<String,Integer>(); 1532 private final Map<String, Class<?>> setterParams = new Hashtable<String,Class<?>>(); 1533 1534 private boolean bitCheck(String name,int...bits){ 1535 Integer id = rightIndexs.get(name); 1536 return (null == id)?false:BeanConverterUtils.bitCheck(id.intValue(),bits); 1537 } 1538 private int[] bitOR(String name,int... bits){ 1539 return BeanConverterUtils.bitOR(rightIndexs.get(name),bits); 1540 } 1541 private void getGetter(String name){ 1542 try{ 1543 methods.put(name,rightType.getMethod(name)); 1544 }catch(NoSuchMethodException e){} 1545 } 1546 private void getSetter(String name, Class<?>...types) throws NoSuchMethodException{ 1547 for(Class<?>paramType:types){ 1548 try{ 1549 methods.put(name,rightType.getMethod(name,paramType)); 1550 setterParams.put(name, paramType); 1551 return; 1552 }catch(NoSuchMethodException e){ 1553 continue; 1554 } 1555 } 1556 throw new NoSuchMethodException(); 1557 } 1558 private void getSetterNoThrow(String name, Class<?>...types){ 1559 try{ 1560 getSetter(name,types); 1561 }catch(NoSuchMethodException e){} 1562 } 1563 /** 1564 * usage: <pre>new FeatureBeanConverter<Model>(javaFields){};</pre> 1565 * @param javaFields a comma splice string,including all field name of R_FEATURE,<br> 1566 * if null or empty, use default string:{@link Constant#FL_FEATURE_JAVA_FIELDS} 1567 */ 1568 public FeatureBeanConverter(String javaFields){ 1569 super(); 1570 init(javaFields); 1571 } 1572 /** @see #FeatureBeanConverter(String) */ 1573 public FeatureBeanConverter(){ 1574 this(null); 1575 } 1576 /** 1577 * constructor 1578 * @param leftClass 1579 * @param rightClass 1580 * @param javaFields see also {@link #FeatureBeanConverter(String)} 1581 */ 1582 public FeatureBeanConverter (Class<FeatureBean> leftClass, Class<R_FEATURE> rightClass,String javaFields){ 1583 super(leftClass,rightClass); 1584 init(javaFields); 1585 } 1586 /** @see #FeatureBeanConverter(Class,Class,String) */ 1587 public FeatureBeanConverter (Class<FeatureBean> leftClass, Class<R_FEATURE> rightClass){ 1588 this(leftClass,rightClass,null); 1589 } 1590 private void init(String javaFields){ 1591 if(null == javaFields || javaFields.isEmpty()){ 1592 javaFields = FL_FEATURE_JAVA_FIELDS; 1593 } 1594 String []rightFields = javaFields.split(","); 1595 for(int i = 0 ; i < rightFields.length; ++i){ 1596 String field = rightFields[i].trim(); 1597 if(!field.matches("\\w+")){ 1598 throw new IllegalArgumentException("invalid 'javaFields':" + javaFields); 1599 } 1600 rightIndexs.put(field,i); 1601 } 1602 try{ 1603 methods.put(IS_NEW,rightType.getMethod(IS_NEW)); 1604 methods.put(GET_INITIALIZED,rightType.getMethod(GET_INITIALIZED)); 1605 getSetter(SET_NEW,boolean.class); 1606 if(rightIndexs.size() > STATE_BIT_NUM){ 1607 getSetter(SET_INITIALIZED,int[].class,List.class); 1608 }else{ 1609 getSetter(SET_INITIALIZED,int.class); 1610 } 1611 getGetter(GET_MODIFIED); 1612 if(rightIndexs.size() > STATE_BIT_NUM){ 1613 getSetter(SET_MODIFIED,int[].class,List.class); 1614 }else{ 1615 getSetter(SET_MODIFIED,int.class); 1616 } 1617 }catch(NoSuchMethodException e){ 1618 throw new RuntimeException(e); 1619 } 1620 1621 getGetter(Column.md5.getter); 1622 getSetterNoThrow(Column.md5.setter,String.class); 1623 getGetter(Column.version.getter); 1624 getSetterNoThrow(Column.version.setter,String.class); 1625 getGetter(Column.personId.getter); 1626 getSetterNoThrow(Column.personId.setter,Integer.class,int.class); 1627 getGetter(Column.feature.getter); 1628 getSetterNoThrow(Column.feature.setter,java.nio.ByteBuffer.class,byte[].class); 1629 getGetter(Column.updateTime.getter); 1630 getSetterNoThrow(Column.updateTime.setter,java.util.Date.class,Long.class,long.class); 1631 } 1632 @Override 1633 protected void doFromRight(FeatureBean left, R_FEATURE right) { 1634 try{ 1635 Method getterMethod; 1636 left.resetIsModified(); 1637 int selfModified = 0; 1638 int[] initialized; 1639 int[] modified; 1640 if(rightIndexs.size() > STATE_BIT_NUM){ 1641 initialized = (int[])methods.get(GET_INITIALIZED).invoke(right); 1642 modified = (int[])methods.get(GET_MODIFIED).invoke(right); 1643 }else{ 1644 initialized = new int[]{(Integer)methods.get(GET_INITIALIZED).invoke(right)}; 1645 modified = new int[]{(Integer)methods.get(GET_MODIFIED).invoke(right)}; 1646 } 1647 if( bitCheck(Column.md5.name(),initialized) && (null != (getterMethod = methods.get(Column.md5.getter)))){ 1648 left.setMd5(cast(String.class,getterMethod.invoke(right))); 1649 if(bitCheck(Column.md5.name(),modified)){ 1650 selfModified |= FL_FEATURE_ID_MD5_MASK; 1651 } 1652 } 1653 if( bitCheck(Column.version.name(),initialized) && (null != (getterMethod = methods.get(Column.version.getter)))){ 1654 left.setVersion(cast(String.class,getterMethod.invoke(right))); 1655 if(bitCheck(Column.version.name(),modified)){ 1656 selfModified |= FL_FEATURE_ID_VERSION_MASK; 1657 } 1658 } 1659 if( bitCheck(Column.personId.name(),initialized) && (null != (getterMethod = methods.get(Column.personId.getter)))){ 1660 left.setPersonId(cast(Integer.class,getterMethod.invoke(right))); 1661 if(bitCheck(Column.personId.name(),modified)){ 1662 selfModified |= FL_FEATURE_ID_PERSON_ID_MASK; 1663 } 1664 } 1665 if( bitCheck(Column.feature.name(),initialized) && (null != (getterMethod = methods.get(Column.feature.getter)))){ 1666 left.setFeature(cast(java.nio.ByteBuffer.class,getterMethod.invoke(right))); 1667 if(bitCheck(Column.feature.name(),modified)){ 1668 selfModified |= FL_FEATURE_ID_FEATURE_MASK; 1669 } 1670 } 1671 if( bitCheck(Column.updateTime.name(),initialized) && (null != (getterMethod = methods.get(Column.updateTime.getter)))){ 1672 left.setUpdateTime(cast(java.util.Date.class,getterMethod.invoke(right))); 1673 if(bitCheck(Column.updateTime.name(),modified)){ 1674 selfModified |= FL_FEATURE_ID_UPDATE_TIME_MASK; 1675 } 1676 } 1677 left.isNew((Boolean)methods.get(IS_NEW).invoke(right)); 1678 left.setModified(selfModified); 1679 }catch(RuntimeException e){ 1680 throw e; 1681 }catch(Exception e){ 1682 throw new RuntimeException(e); 1683 } 1684 } 1685 1686 @Override 1687 protected void doToRight(FeatureBean left, R_FEATURE right) { 1688 try{ 1689 Method setterMethod; 1690 int[] initialized = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 1691 int[] modified = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 1692 Arrays.fill(initialized, 0); 1693 Arrays.fill(modified, 0); 1694 if(null != (setterMethod = methods.get(Column.md5.setter)) && left.checkMd5Initialized()){ 1695 try{ 1696 setterMethod.invoke(right,cast(setterParams.get(Column.md5.setter),left.getMd5())); 1697 bitOR(Column.md5.name(),initialized); 1698 if(left.checkMd5Modified()){ 1699 bitOR(Column.md5.name(),modified); 1700 } 1701 }catch(NullCastPrimitiveException e){} 1702 } 1703 if(null != (setterMethod = methods.get(Column.version.setter)) && left.checkVersionInitialized()){ 1704 try{ 1705 setterMethod.invoke(right,cast(setterParams.get(Column.version.setter),left.getVersion())); 1706 bitOR(Column.version.name(),initialized); 1707 if(left.checkVersionModified()){ 1708 bitOR(Column.version.name(),modified); 1709 } 1710 }catch(NullCastPrimitiveException e){} 1711 } 1712 if(null != (setterMethod = methods.get(Column.personId.setter)) && left.checkPersonIdInitialized()){ 1713 try{ 1714 setterMethod.invoke(right,cast(setterParams.get(Column.personId.setter),left.getPersonId())); 1715 bitOR(Column.personId.name(),initialized); 1716 if(left.checkPersonIdModified()){ 1717 bitOR(Column.personId.name(),modified); 1718 } 1719 }catch(NullCastPrimitiveException e){} 1720 } 1721 if(null != (setterMethod = methods.get(Column.feature.setter)) && left.checkFeatureInitialized()){ 1722 try{ 1723 setterMethod.invoke(right,cast(setterParams.get(Column.feature.setter),left.getFeature())); 1724 bitOR(Column.feature.name(),initialized); 1725 if(left.checkFeatureModified()){ 1726 bitOR(Column.feature.name(),modified); 1727 } 1728 }catch(NullCastPrimitiveException e){} 1729 } 1730// IGNORE field fl_feature.update_time , controlled by 'general.beanconverter.tonative.ignore' in properties file 1731/* 1732 if(null != (setterMethod = methods.get(Column.updateTime.setter)) && left.checkUpdateTimeInitialized()){ 1733 try{ 1734 setterMethod.invoke(right,cast(setterParams.get(Column.updateTime.setter),left.getUpdateTime())); 1735 bitOR(Column.updateTime.name(),initialized); 1736 if(left.checkUpdateTimeModified()){ 1737 bitOR(Column.updateTime.name(),modified); 1738 } 1739 }catch(NullCastPrimitiveException e){} 1740 } 1741*/ 1742 if(null != (setterMethod = methods.get(SET_MODIFIED))){ 1743 if( initialized.length > 1){ 1744 setterMethod.invoke(right,cast(setterParams.get(SET_MODIFIED),initialized)); 1745 }else{ 1746 setterMethod.invoke(right,initialized[0]); 1747 } 1748 } 1749 methods.get(SET_NEW).invoke(right,left.isNew()); 1750 if( initialized.length > 1){ 1751 methods.get(SET_INITIALIZED).invoke(right,cast(setterParams.get(SET_INITIALIZED),initialized)); 1752 methods.get(SET_MODIFIED).invoke(right,cast(setterParams.get(SET_MODIFIED),modified)); 1753 }else{ 1754 methods.get(SET_INITIALIZED).invoke(right,initialized[0]); 1755 methods.get(SET_MODIFIED).invoke(right,modified[0]); 1756 } 1757 }catch(RuntimeException e){ 1758 throw e; 1759 }catch(Exception e){ 1760 throw new RuntimeException(e); 1761 } 1762 } 1763 }; 1764 /** 1765 * implementation of {@link IBeanConverter} by reflect<br> 1766 * generic type converter between {@link ImageBean} and R_IMAGE <br> 1767 * @author guyadong 1768 * @param <R_IMAGE> right type 1769 * 1770 */ 1771 public static class ImageBeanConverter<R_IMAGE> extends IBeanConverter.AbstractHandle<ImageBean,R_IMAGE>{ 1772 static enum Column{ 1773 /** column method info */ 1774 md5("getMd5","setMd5"), 1775 format("getFormat","setFormat"), 1776 width("getWidth","setWidth"), 1777 height("getHeight","setHeight"), 1778 depth("getDepth","setDepth"), 1779 faceNum("getFaceNum","setFaceNum"), 1780 thumbMd5("getThumbMd5","setThumbMd5"), 1781 deviceId("getDeviceId","setDeviceId"); 1782 final String getter; 1783 final String setter; 1784 Column(String getter,String setter){ 1785 this.getter = setter; 1786 this.setter = setter; 1787 } 1788 } 1789 private final Map<String,Method> methods = new Hashtable<String,Method>(); 1790 private final Map<String,Integer> rightIndexs = new Hashtable<String,Integer>(); 1791 private final Map<String, Class<?>> setterParams = new Hashtable<String,Class<?>>(); 1792 1793 private boolean bitCheck(String name,int...bits){ 1794 Integer id = rightIndexs.get(name); 1795 return (null == id)?false:BeanConverterUtils.bitCheck(id.intValue(),bits); 1796 } 1797 private int[] bitOR(String name,int... bits){ 1798 return BeanConverterUtils.bitOR(rightIndexs.get(name),bits); 1799 } 1800 private void getGetter(String name){ 1801 try{ 1802 methods.put(name,rightType.getMethod(name)); 1803 }catch(NoSuchMethodException e){} 1804 } 1805 private void getSetter(String name, Class<?>...types) throws NoSuchMethodException{ 1806 for(Class<?>paramType:types){ 1807 try{ 1808 methods.put(name,rightType.getMethod(name,paramType)); 1809 setterParams.put(name, paramType); 1810 return; 1811 }catch(NoSuchMethodException e){ 1812 continue; 1813 } 1814 } 1815 throw new NoSuchMethodException(); 1816 } 1817 private void getSetterNoThrow(String name, Class<?>...types){ 1818 try{ 1819 getSetter(name,types); 1820 }catch(NoSuchMethodException e){} 1821 } 1822 /** 1823 * usage: <pre>new ImageBeanConverter<Model>(javaFields){};</pre> 1824 * @param javaFields a comma splice string,including all field name of R_IMAGE,<br> 1825 * if null or empty, use default string:{@link Constant#FL_IMAGE_JAVA_FIELDS} 1826 */ 1827 public ImageBeanConverter(String javaFields){ 1828 super(); 1829 init(javaFields); 1830 } 1831 /** @see #ImageBeanConverter(String) */ 1832 public ImageBeanConverter(){ 1833 this(null); 1834 } 1835 /** 1836 * constructor 1837 * @param leftClass 1838 * @param rightClass 1839 * @param javaFields see also {@link #ImageBeanConverter(String)} 1840 */ 1841 public ImageBeanConverter (Class<ImageBean> leftClass, Class<R_IMAGE> rightClass,String javaFields){ 1842 super(leftClass,rightClass); 1843 init(javaFields); 1844 } 1845 /** @see #ImageBeanConverter(Class,Class,String) */ 1846 public ImageBeanConverter (Class<ImageBean> leftClass, Class<R_IMAGE> rightClass){ 1847 this(leftClass,rightClass,null); 1848 } 1849 private void init(String javaFields){ 1850 if(null == javaFields || javaFields.isEmpty()){ 1851 javaFields = FL_IMAGE_JAVA_FIELDS; 1852 } 1853 String []rightFields = javaFields.split(","); 1854 for(int i = 0 ; i < rightFields.length; ++i){ 1855 String field = rightFields[i].trim(); 1856 if(!field.matches("\\w+")){ 1857 throw new IllegalArgumentException("invalid 'javaFields':" + javaFields); 1858 } 1859 rightIndexs.put(field,i); 1860 } 1861 try{ 1862 methods.put(IS_NEW,rightType.getMethod(IS_NEW)); 1863 methods.put(GET_INITIALIZED,rightType.getMethod(GET_INITIALIZED)); 1864 getSetter(SET_NEW,boolean.class); 1865 if(rightIndexs.size() > STATE_BIT_NUM){ 1866 getSetter(SET_INITIALIZED,int[].class,List.class); 1867 }else{ 1868 getSetter(SET_INITIALIZED,int.class); 1869 } 1870 getGetter(GET_MODIFIED); 1871 if(rightIndexs.size() > STATE_BIT_NUM){ 1872 getSetter(SET_MODIFIED,int[].class,List.class); 1873 }else{ 1874 getSetter(SET_MODIFIED,int.class); 1875 } 1876 }catch(NoSuchMethodException e){ 1877 throw new RuntimeException(e); 1878 } 1879 1880 getGetter(Column.md5.getter); 1881 getSetterNoThrow(Column.md5.setter,String.class); 1882 getGetter(Column.format.getter); 1883 getSetterNoThrow(Column.format.setter,String.class); 1884 getGetter(Column.width.getter); 1885 getSetterNoThrow(Column.width.setter,Integer.class,int.class); 1886 getGetter(Column.height.getter); 1887 getSetterNoThrow(Column.height.setter,Integer.class,int.class); 1888 getGetter(Column.depth.getter); 1889 getSetterNoThrow(Column.depth.setter,Integer.class,int.class); 1890 getGetter(Column.faceNum.getter); 1891 getSetterNoThrow(Column.faceNum.setter,Integer.class,int.class); 1892 getGetter(Column.thumbMd5.getter); 1893 getSetterNoThrow(Column.thumbMd5.setter,String.class); 1894 getGetter(Column.deviceId.getter); 1895 getSetterNoThrow(Column.deviceId.setter,Integer.class,int.class); 1896 } 1897 @Override 1898 protected void doFromRight(ImageBean left, R_IMAGE right) { 1899 try{ 1900 Method getterMethod; 1901 left.resetIsModified(); 1902 int selfModified = 0; 1903 int[] initialized; 1904 int[] modified; 1905 if(rightIndexs.size() > STATE_BIT_NUM){ 1906 initialized = (int[])methods.get(GET_INITIALIZED).invoke(right); 1907 modified = (int[])methods.get(GET_MODIFIED).invoke(right); 1908 }else{ 1909 initialized = new int[]{(Integer)methods.get(GET_INITIALIZED).invoke(right)}; 1910 modified = new int[]{(Integer)methods.get(GET_MODIFIED).invoke(right)}; 1911 } 1912 if( bitCheck(Column.md5.name(),initialized) && (null != (getterMethod = methods.get(Column.md5.getter)))){ 1913 left.setMd5(cast(String.class,getterMethod.invoke(right))); 1914 if(bitCheck(Column.md5.name(),modified)){ 1915 selfModified |= FL_IMAGE_ID_MD5_MASK; 1916 } 1917 } 1918 if( bitCheck(Column.format.name(),initialized) && (null != (getterMethod = methods.get(Column.format.getter)))){ 1919 left.setFormat(cast(String.class,getterMethod.invoke(right))); 1920 if(bitCheck(Column.format.name(),modified)){ 1921 selfModified |= FL_IMAGE_ID_FORMAT_MASK; 1922 } 1923 } 1924 if( bitCheck(Column.width.name(),initialized) && (null != (getterMethod = methods.get(Column.width.getter)))){ 1925 left.setWidth(cast(Integer.class,getterMethod.invoke(right))); 1926 if(bitCheck(Column.width.name(),modified)){ 1927 selfModified |= FL_IMAGE_ID_WIDTH_MASK; 1928 } 1929 } 1930 if( bitCheck(Column.height.name(),initialized) && (null != (getterMethod = methods.get(Column.height.getter)))){ 1931 left.setHeight(cast(Integer.class,getterMethod.invoke(right))); 1932 if(bitCheck(Column.height.name(),modified)){ 1933 selfModified |= FL_IMAGE_ID_HEIGHT_MASK; 1934 } 1935 } 1936 if( bitCheck(Column.depth.name(),initialized) && (null != (getterMethod = methods.get(Column.depth.getter)))){ 1937 left.setDepth(cast(Integer.class,getterMethod.invoke(right))); 1938 if(bitCheck(Column.depth.name(),modified)){ 1939 selfModified |= FL_IMAGE_ID_DEPTH_MASK; 1940 } 1941 } 1942 if( bitCheck(Column.faceNum.name(),initialized) && (null != (getterMethod = methods.get(Column.faceNum.getter)))){ 1943 left.setFaceNum(cast(Integer.class,getterMethod.invoke(right))); 1944 if(bitCheck(Column.faceNum.name(),modified)){ 1945 selfModified |= FL_IMAGE_ID_FACE_NUM_MASK; 1946 } 1947 } 1948 if( bitCheck(Column.thumbMd5.name(),initialized) && (null != (getterMethod = methods.get(Column.thumbMd5.getter)))){ 1949 left.setThumbMd5(cast(String.class,getterMethod.invoke(right))); 1950 if(bitCheck(Column.thumbMd5.name(),modified)){ 1951 selfModified |= FL_IMAGE_ID_THUMB_MD5_MASK; 1952 } 1953 } 1954 if( bitCheck(Column.deviceId.name(),initialized) && (null != (getterMethod = methods.get(Column.deviceId.getter)))){ 1955 left.setDeviceId(cast(Integer.class,getterMethod.invoke(right))); 1956 if(bitCheck(Column.deviceId.name(),modified)){ 1957 selfModified |= FL_IMAGE_ID_DEVICE_ID_MASK; 1958 } 1959 } 1960 left.isNew((Boolean)methods.get(IS_NEW).invoke(right)); 1961 left.setModified(selfModified); 1962 }catch(RuntimeException e){ 1963 throw e; 1964 }catch(Exception e){ 1965 throw new RuntimeException(e); 1966 } 1967 } 1968 1969 @Override 1970 protected void doToRight(ImageBean left, R_IMAGE right) { 1971 try{ 1972 Method setterMethod; 1973 int[] initialized = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 1974 int[] modified = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 1975 Arrays.fill(initialized, 0); 1976 Arrays.fill(modified, 0); 1977 if(null != (setterMethod = methods.get(Column.md5.setter)) && left.checkMd5Initialized()){ 1978 try{ 1979 setterMethod.invoke(right,cast(setterParams.get(Column.md5.setter),left.getMd5())); 1980 bitOR(Column.md5.name(),initialized); 1981 if(left.checkMd5Modified()){ 1982 bitOR(Column.md5.name(),modified); 1983 } 1984 }catch(NullCastPrimitiveException e){} 1985 } 1986 if(null != (setterMethod = methods.get(Column.format.setter)) && left.checkFormatInitialized()){ 1987 try{ 1988 setterMethod.invoke(right,cast(setterParams.get(Column.format.setter),left.getFormat())); 1989 bitOR(Column.format.name(),initialized); 1990 if(left.checkFormatModified()){ 1991 bitOR(Column.format.name(),modified); 1992 } 1993 }catch(NullCastPrimitiveException e){} 1994 } 1995 if(null != (setterMethod = methods.get(Column.width.setter)) && left.checkWidthInitialized()){ 1996 try{ 1997 setterMethod.invoke(right,cast(setterParams.get(Column.width.setter),left.getWidth())); 1998 bitOR(Column.width.name(),initialized); 1999 if(left.checkWidthModified()){ 2000 bitOR(Column.width.name(),modified); 2001 } 2002 }catch(NullCastPrimitiveException e){} 2003 } 2004 if(null != (setterMethod = methods.get(Column.height.setter)) && left.checkHeightInitialized()){ 2005 try{ 2006 setterMethod.invoke(right,cast(setterParams.get(Column.height.setter),left.getHeight())); 2007 bitOR(Column.height.name(),initialized); 2008 if(left.checkHeightModified()){ 2009 bitOR(Column.height.name(),modified); 2010 } 2011 }catch(NullCastPrimitiveException e){} 2012 } 2013 if(null != (setterMethod = methods.get(Column.depth.setter)) && left.checkDepthInitialized()){ 2014 try{ 2015 setterMethod.invoke(right,cast(setterParams.get(Column.depth.setter),left.getDepth())); 2016 bitOR(Column.depth.name(),initialized); 2017 if(left.checkDepthModified()){ 2018 bitOR(Column.depth.name(),modified); 2019 } 2020 }catch(NullCastPrimitiveException e){} 2021 } 2022 if(null != (setterMethod = methods.get(Column.faceNum.setter)) && left.checkFaceNumInitialized()){ 2023 try{ 2024 setterMethod.invoke(right,cast(setterParams.get(Column.faceNum.setter),left.getFaceNum())); 2025 bitOR(Column.faceNum.name(),initialized); 2026 if(left.checkFaceNumModified()){ 2027 bitOR(Column.faceNum.name(),modified); 2028 } 2029 }catch(NullCastPrimitiveException e){} 2030 } 2031 if(null != (setterMethod = methods.get(Column.thumbMd5.setter)) && left.checkThumbMd5Initialized()){ 2032 try{ 2033 setterMethod.invoke(right,cast(setterParams.get(Column.thumbMd5.setter),left.getThumbMd5())); 2034 bitOR(Column.thumbMd5.name(),initialized); 2035 if(left.checkThumbMd5Modified()){ 2036 bitOR(Column.thumbMd5.name(),modified); 2037 } 2038 }catch(NullCastPrimitiveException e){} 2039 } 2040 if(null != (setterMethod = methods.get(Column.deviceId.setter)) && left.checkDeviceIdInitialized()){ 2041 try{ 2042 setterMethod.invoke(right,cast(setterParams.get(Column.deviceId.setter),left.getDeviceId())); 2043 bitOR(Column.deviceId.name(),initialized); 2044 if(left.checkDeviceIdModified()){ 2045 bitOR(Column.deviceId.name(),modified); 2046 } 2047 }catch(NullCastPrimitiveException e){} 2048 } 2049 if(null != (setterMethod = methods.get(SET_MODIFIED))){ 2050 if( initialized.length > 1){ 2051 setterMethod.invoke(right,cast(setterParams.get(SET_MODIFIED),initialized)); 2052 }else{ 2053 setterMethod.invoke(right,initialized[0]); 2054 } 2055 } 2056 methods.get(SET_NEW).invoke(right,left.isNew()); 2057 if( initialized.length > 1){ 2058 methods.get(SET_INITIALIZED).invoke(right,cast(setterParams.get(SET_INITIALIZED),initialized)); 2059 methods.get(SET_MODIFIED).invoke(right,cast(setterParams.get(SET_MODIFIED),modified)); 2060 }else{ 2061 methods.get(SET_INITIALIZED).invoke(right,initialized[0]); 2062 methods.get(SET_MODIFIED).invoke(right,modified[0]); 2063 } 2064 }catch(RuntimeException e){ 2065 throw e; 2066 }catch(Exception e){ 2067 throw new RuntimeException(e); 2068 } 2069 } 2070 }; 2071 /** 2072 * implementation of {@link IBeanConverter} by reflect<br> 2073 * generic type converter between {@link LogBean} and R_LOG <br> 2074 * @author guyadong 2075 * @param <R_LOG> right type 2076 * 2077 */ 2078 public static class LogBeanConverter<R_LOG> extends IBeanConverter.AbstractHandle<LogBean,R_LOG>{ 2079 static enum Column{ 2080 /** column method info */ 2081 id("getId","setId"), 2082 personId("getPersonId","setPersonId"), 2083 deviceId("getDeviceId","setDeviceId"), 2084 verifyFeature("getVerifyFeature","setVerifyFeature"), 2085 compareFace("getCompareFace","setCompareFace"), 2086 verifyStatus("getVerifyStatus","setVerifyStatus"), 2087 similarty("getSimilarty","setSimilarty"), 2088 direction("getDirection","setDirection"), 2089 verifyTime("getVerifyTime","setVerifyTime"), 2090 createTime("getCreateTime","setCreateTime"); 2091 final String getter; 2092 final String setter; 2093 Column(String getter,String setter){ 2094 this.getter = setter; 2095 this.setter = setter; 2096 } 2097 } 2098 private final Map<String,Method> methods = new Hashtable<String,Method>(); 2099 private final Map<String,Integer> rightIndexs = new Hashtable<String,Integer>(); 2100 private final Map<String, Class<?>> setterParams = new Hashtable<String,Class<?>>(); 2101 2102 private boolean bitCheck(String name,int...bits){ 2103 Integer id = rightIndexs.get(name); 2104 return (null == id)?false:BeanConverterUtils.bitCheck(id.intValue(),bits); 2105 } 2106 private int[] bitOR(String name,int... bits){ 2107 return BeanConverterUtils.bitOR(rightIndexs.get(name),bits); 2108 } 2109 private void getGetter(String name){ 2110 try{ 2111 methods.put(name,rightType.getMethod(name)); 2112 }catch(NoSuchMethodException e){} 2113 } 2114 private void getSetter(String name, Class<?>...types) throws NoSuchMethodException{ 2115 for(Class<?>paramType:types){ 2116 try{ 2117 methods.put(name,rightType.getMethod(name,paramType)); 2118 setterParams.put(name, paramType); 2119 return; 2120 }catch(NoSuchMethodException e){ 2121 continue; 2122 } 2123 } 2124 throw new NoSuchMethodException(); 2125 } 2126 private void getSetterNoThrow(String name, Class<?>...types){ 2127 try{ 2128 getSetter(name,types); 2129 }catch(NoSuchMethodException e){} 2130 } 2131 /** 2132 * usage: <pre>new LogBeanConverter<Model>(javaFields){};</pre> 2133 * @param javaFields a comma splice string,including all field name of R_LOG,<br> 2134 * if null or empty, use default string:{@link Constant#FL_LOG_JAVA_FIELDS} 2135 */ 2136 public LogBeanConverter(String javaFields){ 2137 super(); 2138 init(javaFields); 2139 } 2140 /** @see #LogBeanConverter(String) */ 2141 public LogBeanConverter(){ 2142 this(null); 2143 } 2144 /** 2145 * constructor 2146 * @param leftClass 2147 * @param rightClass 2148 * @param javaFields see also {@link #LogBeanConverter(String)} 2149 */ 2150 public LogBeanConverter (Class<LogBean> leftClass, Class<R_LOG> rightClass,String javaFields){ 2151 super(leftClass,rightClass); 2152 init(javaFields); 2153 } 2154 /** @see #LogBeanConverter(Class,Class,String) */ 2155 public LogBeanConverter (Class<LogBean> leftClass, Class<R_LOG> rightClass){ 2156 this(leftClass,rightClass,null); 2157 } 2158 private void init(String javaFields){ 2159 if(null == javaFields || javaFields.isEmpty()){ 2160 javaFields = FL_LOG_JAVA_FIELDS; 2161 } 2162 String []rightFields = javaFields.split(","); 2163 for(int i = 0 ; i < rightFields.length; ++i){ 2164 String field = rightFields[i].trim(); 2165 if(!field.matches("\\w+")){ 2166 throw new IllegalArgumentException("invalid 'javaFields':" + javaFields); 2167 } 2168 rightIndexs.put(field,i); 2169 } 2170 try{ 2171 methods.put(IS_NEW,rightType.getMethod(IS_NEW)); 2172 methods.put(GET_INITIALIZED,rightType.getMethod(GET_INITIALIZED)); 2173 getSetter(SET_NEW,boolean.class); 2174 if(rightIndexs.size() > STATE_BIT_NUM){ 2175 getSetter(SET_INITIALIZED,int[].class,List.class); 2176 }else{ 2177 getSetter(SET_INITIALIZED,int.class); 2178 } 2179 getGetter(GET_MODIFIED); 2180 if(rightIndexs.size() > STATE_BIT_NUM){ 2181 getSetter(SET_MODIFIED,int[].class,List.class); 2182 }else{ 2183 getSetter(SET_MODIFIED,int.class); 2184 } 2185 }catch(NoSuchMethodException e){ 2186 throw new RuntimeException(e); 2187 } 2188 2189 getGetter(Column.id.getter); 2190 getSetterNoThrow(Column.id.setter,Integer.class,int.class); 2191 getGetter(Column.personId.getter); 2192 getSetterNoThrow(Column.personId.setter,Integer.class,int.class); 2193 getGetter(Column.deviceId.getter); 2194 getSetterNoThrow(Column.deviceId.setter,Integer.class,int.class); 2195 getGetter(Column.verifyFeature.getter); 2196 getSetterNoThrow(Column.verifyFeature.setter,String.class); 2197 getGetter(Column.compareFace.getter); 2198 getSetterNoThrow(Column.compareFace.setter,Integer.class,int.class); 2199 getGetter(Column.verifyStatus.getter); 2200 getSetterNoThrow(Column.verifyStatus.setter,Integer.class,int.class); 2201 getGetter(Column.similarty.getter); 2202 getSetterNoThrow(Column.similarty.setter,Double.class,double.class); 2203 getGetter(Column.direction.getter); 2204 getSetterNoThrow(Column.direction.setter,Integer.class,int.class); 2205 getGetter(Column.verifyTime.getter); 2206 getSetterNoThrow(Column.verifyTime.setter,java.util.Date.class,Long.class,long.class); 2207 getGetter(Column.createTime.getter); 2208 getSetterNoThrow(Column.createTime.setter,java.util.Date.class,Long.class,long.class); 2209 } 2210 @Override 2211 protected void doFromRight(LogBean left, R_LOG right) { 2212 try{ 2213 Method getterMethod; 2214 left.resetIsModified(); 2215 int selfModified = 0; 2216 int[] initialized; 2217 int[] modified; 2218 if(rightIndexs.size() > STATE_BIT_NUM){ 2219 initialized = (int[])methods.get(GET_INITIALIZED).invoke(right); 2220 modified = (int[])methods.get(GET_MODIFIED).invoke(right); 2221 }else{ 2222 initialized = new int[]{(Integer)methods.get(GET_INITIALIZED).invoke(right)}; 2223 modified = new int[]{(Integer)methods.get(GET_MODIFIED).invoke(right)}; 2224 } 2225 if( bitCheck(Column.id.name(),initialized) && (null != (getterMethod = methods.get(Column.id.getter)))){ 2226 left.setId(cast(Integer.class,getterMethod.invoke(right))); 2227 if(bitCheck(Column.id.name(),modified)){ 2228 selfModified |= FL_LOG_ID_ID_MASK; 2229 } 2230 } 2231 if( bitCheck(Column.personId.name(),initialized) && (null != (getterMethod = methods.get(Column.personId.getter)))){ 2232 left.setPersonId(cast(Integer.class,getterMethod.invoke(right))); 2233 if(bitCheck(Column.personId.name(),modified)){ 2234 selfModified |= FL_LOG_ID_PERSON_ID_MASK; 2235 } 2236 } 2237 if( bitCheck(Column.deviceId.name(),initialized) && (null != (getterMethod = methods.get(Column.deviceId.getter)))){ 2238 left.setDeviceId(cast(Integer.class,getterMethod.invoke(right))); 2239 if(bitCheck(Column.deviceId.name(),modified)){ 2240 selfModified |= FL_LOG_ID_DEVICE_ID_MASK; 2241 } 2242 } 2243 if( bitCheck(Column.verifyFeature.name(),initialized) && (null != (getterMethod = methods.get(Column.verifyFeature.getter)))){ 2244 left.setVerifyFeature(cast(String.class,getterMethod.invoke(right))); 2245 if(bitCheck(Column.verifyFeature.name(),modified)){ 2246 selfModified |= FL_LOG_ID_VERIFY_FEATURE_MASK; 2247 } 2248 } 2249 if( bitCheck(Column.compareFace.name(),initialized) && (null != (getterMethod = methods.get(Column.compareFace.getter)))){ 2250 left.setCompareFace(cast(Integer.class,getterMethod.invoke(right))); 2251 if(bitCheck(Column.compareFace.name(),modified)){ 2252 selfModified |= FL_LOG_ID_COMPARE_FACE_MASK; 2253 } 2254 } 2255 if( bitCheck(Column.verifyStatus.name(),initialized) && (null != (getterMethod = methods.get(Column.verifyStatus.getter)))){ 2256 left.setVerifyStatus(cast(Integer.class,getterMethod.invoke(right))); 2257 if(bitCheck(Column.verifyStatus.name(),modified)){ 2258 selfModified |= FL_LOG_ID_VERIFY_STATUS_MASK; 2259 } 2260 } 2261 if( bitCheck(Column.similarty.name(),initialized) && (null != (getterMethod = methods.get(Column.similarty.getter)))){ 2262 left.setSimilarty(cast(Double.class,getterMethod.invoke(right))); 2263 if(bitCheck(Column.similarty.name(),modified)){ 2264 selfModified |= FL_LOG_ID_SIMILARTY_MASK; 2265 } 2266 } 2267 if( bitCheck(Column.direction.name(),initialized) && (null != (getterMethod = methods.get(Column.direction.getter)))){ 2268 left.setDirection(cast(Integer.class,getterMethod.invoke(right))); 2269 if(bitCheck(Column.direction.name(),modified)){ 2270 selfModified |= FL_LOG_ID_DIRECTION_MASK; 2271 } 2272 } 2273 if( bitCheck(Column.verifyTime.name(),initialized) && (null != (getterMethod = methods.get(Column.verifyTime.getter)))){ 2274 left.setVerifyTime(cast(java.util.Date.class,getterMethod.invoke(right))); 2275 if(bitCheck(Column.verifyTime.name(),modified)){ 2276 selfModified |= FL_LOG_ID_VERIFY_TIME_MASK; 2277 } 2278 } 2279 if( bitCheck(Column.createTime.name(),initialized) && (null != (getterMethod = methods.get(Column.createTime.getter)))){ 2280 left.setCreateTime(cast(java.util.Date.class,getterMethod.invoke(right))); 2281 if(bitCheck(Column.createTime.name(),modified)){ 2282 selfModified |= FL_LOG_ID_CREATE_TIME_MASK; 2283 } 2284 } 2285 left.isNew((Boolean)methods.get(IS_NEW).invoke(right)); 2286 left.setModified(selfModified); 2287 }catch(RuntimeException e){ 2288 throw e; 2289 }catch(Exception e){ 2290 throw new RuntimeException(e); 2291 } 2292 } 2293 2294 @Override 2295 protected void doToRight(LogBean left, R_LOG right) { 2296 try{ 2297 Method setterMethod; 2298 int[] initialized = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 2299 int[] modified = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 2300 Arrays.fill(initialized, 0); 2301 Arrays.fill(modified, 0); 2302 if(null != (setterMethod = methods.get(Column.id.setter)) && left.checkIdInitialized()){ 2303 try{ 2304 setterMethod.invoke(right,cast(setterParams.get(Column.id.setter),left.getId())); 2305 bitOR(Column.id.name(),initialized); 2306 if(left.checkIdModified()){ 2307 bitOR(Column.id.name(),modified); 2308 } 2309 }catch(NullCastPrimitiveException e){} 2310 } 2311 if(null != (setterMethod = methods.get(Column.personId.setter)) && left.checkPersonIdInitialized()){ 2312 try{ 2313 setterMethod.invoke(right,cast(setterParams.get(Column.personId.setter),left.getPersonId())); 2314 bitOR(Column.personId.name(),initialized); 2315 if(left.checkPersonIdModified()){ 2316 bitOR(Column.personId.name(),modified); 2317 } 2318 }catch(NullCastPrimitiveException e){} 2319 } 2320 if(null != (setterMethod = methods.get(Column.deviceId.setter)) && left.checkDeviceIdInitialized()){ 2321 try{ 2322 setterMethod.invoke(right,cast(setterParams.get(Column.deviceId.setter),left.getDeviceId())); 2323 bitOR(Column.deviceId.name(),initialized); 2324 if(left.checkDeviceIdModified()){ 2325 bitOR(Column.deviceId.name(),modified); 2326 } 2327 }catch(NullCastPrimitiveException e){} 2328 } 2329 if(null != (setterMethod = methods.get(Column.verifyFeature.setter)) && left.checkVerifyFeatureInitialized()){ 2330 try{ 2331 setterMethod.invoke(right,cast(setterParams.get(Column.verifyFeature.setter),left.getVerifyFeature())); 2332 bitOR(Column.verifyFeature.name(),initialized); 2333 if(left.checkVerifyFeatureModified()){ 2334 bitOR(Column.verifyFeature.name(),modified); 2335 } 2336 }catch(NullCastPrimitiveException e){} 2337 } 2338 if(null != (setterMethod = methods.get(Column.compareFace.setter)) && left.checkCompareFaceInitialized()){ 2339 try{ 2340 setterMethod.invoke(right,cast(setterParams.get(Column.compareFace.setter),left.getCompareFace())); 2341 bitOR(Column.compareFace.name(),initialized); 2342 if(left.checkCompareFaceModified()){ 2343 bitOR(Column.compareFace.name(),modified); 2344 } 2345 }catch(NullCastPrimitiveException e){} 2346 } 2347 if(null != (setterMethod = methods.get(Column.verifyStatus.setter)) && left.checkVerifyStatusInitialized()){ 2348 try{ 2349 setterMethod.invoke(right,cast(setterParams.get(Column.verifyStatus.setter),left.getVerifyStatus())); 2350 bitOR(Column.verifyStatus.name(),initialized); 2351 if(left.checkVerifyStatusModified()){ 2352 bitOR(Column.verifyStatus.name(),modified); 2353 } 2354 }catch(NullCastPrimitiveException e){} 2355 } 2356 if(null != (setterMethod = methods.get(Column.similarty.setter)) && left.checkSimilartyInitialized()){ 2357 try{ 2358 setterMethod.invoke(right,cast(setterParams.get(Column.similarty.setter),left.getSimilarty())); 2359 bitOR(Column.similarty.name(),initialized); 2360 if(left.checkSimilartyModified()){ 2361 bitOR(Column.similarty.name(),modified); 2362 } 2363 }catch(NullCastPrimitiveException e){} 2364 } 2365 if(null != (setterMethod = methods.get(Column.direction.setter)) && left.checkDirectionInitialized()){ 2366 try{ 2367 setterMethod.invoke(right,cast(setterParams.get(Column.direction.setter),left.getDirection())); 2368 bitOR(Column.direction.name(),initialized); 2369 if(left.checkDirectionModified()){ 2370 bitOR(Column.direction.name(),modified); 2371 } 2372 }catch(NullCastPrimitiveException e){} 2373 } 2374 if(null != (setterMethod = methods.get(Column.verifyTime.setter)) && left.checkVerifyTimeInitialized()){ 2375 try{ 2376 setterMethod.invoke(right,cast(setterParams.get(Column.verifyTime.setter),left.getVerifyTime())); 2377 bitOR(Column.verifyTime.name(),initialized); 2378 if(left.checkVerifyTimeModified()){ 2379 bitOR(Column.verifyTime.name(),modified); 2380 } 2381 }catch(NullCastPrimitiveException e){} 2382 } 2383// IGNORE field fl_log.create_time , controlled by 'general.beanconverter.tonative.ignore' in properties file 2384/* 2385 if(null != (setterMethod = methods.get(Column.createTime.setter)) && left.checkCreateTimeInitialized()){ 2386 try{ 2387 setterMethod.invoke(right,cast(setterParams.get(Column.createTime.setter),left.getCreateTime())); 2388 bitOR(Column.createTime.name(),initialized); 2389 if(left.checkCreateTimeModified()){ 2390 bitOR(Column.createTime.name(),modified); 2391 } 2392 }catch(NullCastPrimitiveException e){} 2393 } 2394*/ 2395 if(null != (setterMethod = methods.get(SET_MODIFIED))){ 2396 if( initialized.length > 1){ 2397 setterMethod.invoke(right,cast(setterParams.get(SET_MODIFIED),initialized)); 2398 }else{ 2399 setterMethod.invoke(right,initialized[0]); 2400 } 2401 } 2402 methods.get(SET_NEW).invoke(right,left.isNew()); 2403 if( initialized.length > 1){ 2404 methods.get(SET_INITIALIZED).invoke(right,cast(setterParams.get(SET_INITIALIZED),initialized)); 2405 methods.get(SET_MODIFIED).invoke(right,cast(setterParams.get(SET_MODIFIED),modified)); 2406 }else{ 2407 methods.get(SET_INITIALIZED).invoke(right,initialized[0]); 2408 methods.get(SET_MODIFIED).invoke(right,modified[0]); 2409 } 2410 }catch(RuntimeException e){ 2411 throw e; 2412 }catch(Exception e){ 2413 throw new RuntimeException(e); 2414 } 2415 } 2416 }; 2417 /** 2418 * implementation of {@link IBeanConverter} by reflect<br> 2419 * generic type converter between {@link PermitBean} and R_PERMIT <br> 2420 * @author guyadong 2421 * @param <R_PERMIT> right type 2422 * 2423 */ 2424 public static class PermitBeanConverter<R_PERMIT> extends IBeanConverter.AbstractHandle<PermitBean,R_PERMIT>{ 2425 static enum Column{ 2426 /** column method info */ 2427 deviceGroupId("getDeviceGroupId","setDeviceGroupId"), 2428 personGroupId("getPersonGroupId","setPersonGroupId"), 2429 schedule("getSchedule","setSchedule"), 2430 passLimit("getPassLimit","setPassLimit"), 2431 remark("getRemark","setRemark"), 2432 extBin("getExtBin","setExtBin"), 2433 extTxt("getExtTxt","setExtTxt"), 2434 createTime("getCreateTime","setCreateTime"); 2435 final String getter; 2436 final String setter; 2437 Column(String getter,String setter){ 2438 this.getter = setter; 2439 this.setter = setter; 2440 } 2441 } 2442 private final Map<String,Method> methods = new Hashtable<String,Method>(); 2443 private final Map<String,Integer> rightIndexs = new Hashtable<String,Integer>(); 2444 private final Map<String, Class<?>> setterParams = new Hashtable<String,Class<?>>(); 2445 2446 private boolean bitCheck(String name,int...bits){ 2447 Integer id = rightIndexs.get(name); 2448 return (null == id)?false:BeanConverterUtils.bitCheck(id.intValue(),bits); 2449 } 2450 private int[] bitOR(String name,int... bits){ 2451 return BeanConverterUtils.bitOR(rightIndexs.get(name),bits); 2452 } 2453 private void getGetter(String name){ 2454 try{ 2455 methods.put(name,rightType.getMethod(name)); 2456 }catch(NoSuchMethodException e){} 2457 } 2458 private void getSetter(String name, Class<?>...types) throws NoSuchMethodException{ 2459 for(Class<?>paramType:types){ 2460 try{ 2461 methods.put(name,rightType.getMethod(name,paramType)); 2462 setterParams.put(name, paramType); 2463 return; 2464 }catch(NoSuchMethodException e){ 2465 continue; 2466 } 2467 } 2468 throw new NoSuchMethodException(); 2469 } 2470 private void getSetterNoThrow(String name, Class<?>...types){ 2471 try{ 2472 getSetter(name,types); 2473 }catch(NoSuchMethodException e){} 2474 } 2475 /** 2476 * usage: <pre>new PermitBeanConverter<Model>(javaFields){};</pre> 2477 * @param javaFields a comma splice string,including all field name of R_PERMIT,<br> 2478 * if null or empty, use default string:{@link Constant#FL_PERMIT_JAVA_FIELDS} 2479 */ 2480 public PermitBeanConverter(String javaFields){ 2481 super(); 2482 init(javaFields); 2483 } 2484 /** @see #PermitBeanConverter(String) */ 2485 public PermitBeanConverter(){ 2486 this(null); 2487 } 2488 /** 2489 * constructor 2490 * @param leftClass 2491 * @param rightClass 2492 * @param javaFields see also {@link #PermitBeanConverter(String)} 2493 */ 2494 public PermitBeanConverter (Class<PermitBean> leftClass, Class<R_PERMIT> rightClass,String javaFields){ 2495 super(leftClass,rightClass); 2496 init(javaFields); 2497 } 2498 /** @see #PermitBeanConverter(Class,Class,String) */ 2499 public PermitBeanConverter (Class<PermitBean> leftClass, Class<R_PERMIT> rightClass){ 2500 this(leftClass,rightClass,null); 2501 } 2502 private void init(String javaFields){ 2503 if(null == javaFields || javaFields.isEmpty()){ 2504 javaFields = FL_PERMIT_JAVA_FIELDS; 2505 } 2506 String []rightFields = javaFields.split(","); 2507 for(int i = 0 ; i < rightFields.length; ++i){ 2508 String field = rightFields[i].trim(); 2509 if(!field.matches("\\w+")){ 2510 throw new IllegalArgumentException("invalid 'javaFields':" + javaFields); 2511 } 2512 rightIndexs.put(field,i); 2513 } 2514 try{ 2515 methods.put(IS_NEW,rightType.getMethod(IS_NEW)); 2516 methods.put(GET_INITIALIZED,rightType.getMethod(GET_INITIALIZED)); 2517 getSetter(SET_NEW,boolean.class); 2518 if(rightIndexs.size() > STATE_BIT_NUM){ 2519 getSetter(SET_INITIALIZED,int[].class,List.class); 2520 }else{ 2521 getSetter(SET_INITIALIZED,int.class); 2522 } 2523 getGetter(GET_MODIFIED); 2524 if(rightIndexs.size() > STATE_BIT_NUM){ 2525 getSetter(SET_MODIFIED,int[].class,List.class); 2526 }else{ 2527 getSetter(SET_MODIFIED,int.class); 2528 } 2529 }catch(NoSuchMethodException e){ 2530 throw new RuntimeException(e); 2531 } 2532 2533 getGetter(Column.deviceGroupId.getter); 2534 getSetterNoThrow(Column.deviceGroupId.setter,Integer.class,int.class); 2535 getGetter(Column.personGroupId.getter); 2536 getSetterNoThrow(Column.personGroupId.setter,Integer.class,int.class); 2537 getGetter(Column.schedule.getter); 2538 getSetterNoThrow(Column.schedule.setter,String.class); 2539 getGetter(Column.passLimit.getter); 2540 getSetterNoThrow(Column.passLimit.setter,String.class); 2541 getGetter(Column.remark.getter); 2542 getSetterNoThrow(Column.remark.setter,String.class); 2543 getGetter(Column.extBin.getter); 2544 getSetterNoThrow(Column.extBin.setter,java.nio.ByteBuffer.class,byte[].class); 2545 getGetter(Column.extTxt.getter); 2546 getSetterNoThrow(Column.extTxt.setter,String.class); 2547 getGetter(Column.createTime.getter); 2548 getSetterNoThrow(Column.createTime.setter,java.util.Date.class,Long.class,long.class); 2549 } 2550 @Override 2551 protected void doFromRight(PermitBean left, R_PERMIT right) { 2552 try{ 2553 Method getterMethod; 2554 left.resetIsModified(); 2555 int selfModified = 0; 2556 int[] initialized; 2557 int[] modified; 2558 if(rightIndexs.size() > STATE_BIT_NUM){ 2559 initialized = (int[])methods.get(GET_INITIALIZED).invoke(right); 2560 modified = (int[])methods.get(GET_MODIFIED).invoke(right); 2561 }else{ 2562 initialized = new int[]{(Integer)methods.get(GET_INITIALIZED).invoke(right)}; 2563 modified = new int[]{(Integer)methods.get(GET_MODIFIED).invoke(right)}; 2564 } 2565 if( bitCheck(Column.deviceGroupId.name(),initialized) && (null != (getterMethod = methods.get(Column.deviceGroupId.getter)))){ 2566 left.setDeviceGroupId(cast(Integer.class,getterMethod.invoke(right))); 2567 if(bitCheck(Column.deviceGroupId.name(),modified)){ 2568 selfModified |= FL_PERMIT_ID_DEVICE_GROUP_ID_MASK; 2569 } 2570 } 2571 if( bitCheck(Column.personGroupId.name(),initialized) && (null != (getterMethod = methods.get(Column.personGroupId.getter)))){ 2572 left.setPersonGroupId(cast(Integer.class,getterMethod.invoke(right))); 2573 if(bitCheck(Column.personGroupId.name(),modified)){ 2574 selfModified |= FL_PERMIT_ID_PERSON_GROUP_ID_MASK; 2575 } 2576 } 2577 if( bitCheck(Column.schedule.name(),initialized) && (null != (getterMethod = methods.get(Column.schedule.getter)))){ 2578 left.setSchedule(cast(String.class,getterMethod.invoke(right))); 2579 if(bitCheck(Column.schedule.name(),modified)){ 2580 selfModified |= FL_PERMIT_ID_SCHEDULE_MASK; 2581 } 2582 } 2583 if( bitCheck(Column.passLimit.name(),initialized) && (null != (getterMethod = methods.get(Column.passLimit.getter)))){ 2584 left.setPassLimit(cast(String.class,getterMethod.invoke(right))); 2585 if(bitCheck(Column.passLimit.name(),modified)){ 2586 selfModified |= FL_PERMIT_ID_PASS_LIMIT_MASK; 2587 } 2588 } 2589 if( bitCheck(Column.remark.name(),initialized) && (null != (getterMethod = methods.get(Column.remark.getter)))){ 2590 left.setRemark(cast(String.class,getterMethod.invoke(right))); 2591 if(bitCheck(Column.remark.name(),modified)){ 2592 selfModified |= FL_PERMIT_ID_REMARK_MASK; 2593 } 2594 } 2595 if( bitCheck(Column.extBin.name(),initialized) && (null != (getterMethod = methods.get(Column.extBin.getter)))){ 2596 left.setExtBin(cast(java.nio.ByteBuffer.class,getterMethod.invoke(right))); 2597 if(bitCheck(Column.extBin.name(),modified)){ 2598 selfModified |= FL_PERMIT_ID_EXT_BIN_MASK; 2599 } 2600 } 2601 if( bitCheck(Column.extTxt.name(),initialized) && (null != (getterMethod = methods.get(Column.extTxt.getter)))){ 2602 left.setExtTxt(cast(String.class,getterMethod.invoke(right))); 2603 if(bitCheck(Column.extTxt.name(),modified)){ 2604 selfModified |= FL_PERMIT_ID_EXT_TXT_MASK; 2605 } 2606 } 2607 if( bitCheck(Column.createTime.name(),initialized) && (null != (getterMethod = methods.get(Column.createTime.getter)))){ 2608 left.setCreateTime(cast(java.util.Date.class,getterMethod.invoke(right))); 2609 if(bitCheck(Column.createTime.name(),modified)){ 2610 selfModified |= FL_PERMIT_ID_CREATE_TIME_MASK; 2611 } 2612 } 2613 left.isNew((Boolean)methods.get(IS_NEW).invoke(right)); 2614 left.setModified(selfModified); 2615 }catch(RuntimeException e){ 2616 throw e; 2617 }catch(Exception e){ 2618 throw new RuntimeException(e); 2619 } 2620 } 2621 2622 @Override 2623 protected void doToRight(PermitBean left, R_PERMIT right) { 2624 try{ 2625 Method setterMethod; 2626 int[] initialized = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 2627 int[] modified = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 2628 Arrays.fill(initialized, 0); 2629 Arrays.fill(modified, 0); 2630 if(null != (setterMethod = methods.get(Column.deviceGroupId.setter)) && left.checkDeviceGroupIdInitialized()){ 2631 try{ 2632 setterMethod.invoke(right,cast(setterParams.get(Column.deviceGroupId.setter),left.getDeviceGroupId())); 2633 bitOR(Column.deviceGroupId.name(),initialized); 2634 if(left.checkDeviceGroupIdModified()){ 2635 bitOR(Column.deviceGroupId.name(),modified); 2636 } 2637 }catch(NullCastPrimitiveException e){} 2638 } 2639 if(null != (setterMethod = methods.get(Column.personGroupId.setter)) && left.checkPersonGroupIdInitialized()){ 2640 try{ 2641 setterMethod.invoke(right,cast(setterParams.get(Column.personGroupId.setter),left.getPersonGroupId())); 2642 bitOR(Column.personGroupId.name(),initialized); 2643 if(left.checkPersonGroupIdModified()){ 2644 bitOR(Column.personGroupId.name(),modified); 2645 } 2646 }catch(NullCastPrimitiveException e){} 2647 } 2648 if(null != (setterMethod = methods.get(Column.schedule.setter)) && left.checkScheduleInitialized()){ 2649 try{ 2650 setterMethod.invoke(right,cast(setterParams.get(Column.schedule.setter),left.getSchedule())); 2651 bitOR(Column.schedule.name(),initialized); 2652 if(left.checkScheduleModified()){ 2653 bitOR(Column.schedule.name(),modified); 2654 } 2655 }catch(NullCastPrimitiveException e){} 2656 } 2657 if(null != (setterMethod = methods.get(Column.passLimit.setter)) && left.checkPassLimitInitialized()){ 2658 try{ 2659 setterMethod.invoke(right,cast(setterParams.get(Column.passLimit.setter),left.getPassLimit())); 2660 bitOR(Column.passLimit.name(),initialized); 2661 if(left.checkPassLimitModified()){ 2662 bitOR(Column.passLimit.name(),modified); 2663 } 2664 }catch(NullCastPrimitiveException e){} 2665 } 2666 if(null != (setterMethod = methods.get(Column.remark.setter)) && left.checkRemarkInitialized()){ 2667 try{ 2668 setterMethod.invoke(right,cast(setterParams.get(Column.remark.setter),left.getRemark())); 2669 bitOR(Column.remark.name(),initialized); 2670 if(left.checkRemarkModified()){ 2671 bitOR(Column.remark.name(),modified); 2672 } 2673 }catch(NullCastPrimitiveException e){} 2674 } 2675 if(null != (setterMethod = methods.get(Column.extBin.setter)) && left.checkExtBinInitialized()){ 2676 try{ 2677 setterMethod.invoke(right,cast(setterParams.get(Column.extBin.setter),left.getExtBin())); 2678 bitOR(Column.extBin.name(),initialized); 2679 if(left.checkExtBinModified()){ 2680 bitOR(Column.extBin.name(),modified); 2681 } 2682 }catch(NullCastPrimitiveException e){} 2683 } 2684 if(null != (setterMethod = methods.get(Column.extTxt.setter)) && left.checkExtTxtInitialized()){ 2685 try{ 2686 setterMethod.invoke(right,cast(setterParams.get(Column.extTxt.setter),left.getExtTxt())); 2687 bitOR(Column.extTxt.name(),initialized); 2688 if(left.checkExtTxtModified()){ 2689 bitOR(Column.extTxt.name(),modified); 2690 } 2691 }catch(NullCastPrimitiveException e){} 2692 } 2693// IGNORE field fl_permit.create_time , controlled by 'general.beanconverter.tonative.ignore' in properties file 2694/* 2695 if(null != (setterMethod = methods.get(Column.createTime.setter)) && left.checkCreateTimeInitialized()){ 2696 try{ 2697 setterMethod.invoke(right,cast(setterParams.get(Column.createTime.setter),left.getCreateTime())); 2698 bitOR(Column.createTime.name(),initialized); 2699 if(left.checkCreateTimeModified()){ 2700 bitOR(Column.createTime.name(),modified); 2701 } 2702 }catch(NullCastPrimitiveException e){} 2703 } 2704*/ 2705 if(null != (setterMethod = methods.get(SET_MODIFIED))){ 2706 if( initialized.length > 1){ 2707 setterMethod.invoke(right,cast(setterParams.get(SET_MODIFIED),initialized)); 2708 }else{ 2709 setterMethod.invoke(right,initialized[0]); 2710 } 2711 } 2712 methods.get(SET_NEW).invoke(right,left.isNew()); 2713 if( initialized.length > 1){ 2714 methods.get(SET_INITIALIZED).invoke(right,cast(setterParams.get(SET_INITIALIZED),initialized)); 2715 methods.get(SET_MODIFIED).invoke(right,cast(setterParams.get(SET_MODIFIED),modified)); 2716 }else{ 2717 methods.get(SET_INITIALIZED).invoke(right,initialized[0]); 2718 methods.get(SET_MODIFIED).invoke(right,modified[0]); 2719 } 2720 }catch(RuntimeException e){ 2721 throw e; 2722 }catch(Exception e){ 2723 throw new RuntimeException(e); 2724 } 2725 } 2726 }; 2727 /** 2728 * implementation of {@link IBeanConverter} by reflect<br> 2729 * generic type converter between {@link PersonBean} and R_PERSON <br> 2730 * @author guyadong 2731 * @param <R_PERSON> right type 2732 * 2733 */ 2734 public static class PersonBeanConverter<R_PERSON> extends IBeanConverter.AbstractHandle<PersonBean,R_PERSON>{ 2735 static enum Column{ 2736 /** column method info */ 2737 id("getId","setId"), 2738 groupId("getGroupId","setGroupId"), 2739 name("getName","setName"), 2740 sex("getSex","setSex"), 2741 rank("getRank","setRank"), 2742 password("getPassword","setPassword"), 2743 birthdate("getBirthdate","setBirthdate"), 2744 mobilePhone("getMobilePhone","setMobilePhone"), 2745 papersType("getPapersType","setPapersType"), 2746 papersNum("getPapersNum","setPapersNum"), 2747 imageMd5("getImageMd5","setImageMd5"), 2748 expiryDate("getExpiryDate","setExpiryDate"), 2749 activatedDate("getActivatedDate","setActivatedDate"), 2750 remark("getRemark","setRemark"), 2751 extBin("getExtBin","setExtBin"), 2752 extTxt("getExtTxt","setExtTxt"), 2753 createTime("getCreateTime","setCreateTime"), 2754 updateTime("getUpdateTime","setUpdateTime"); 2755 final String getter; 2756 final String setter; 2757 Column(String getter,String setter){ 2758 this.getter = setter; 2759 this.setter = setter; 2760 } 2761 } 2762 private final Map<String,Method> methods = new Hashtable<String,Method>(); 2763 private final Map<String,Integer> rightIndexs = new Hashtable<String,Integer>(); 2764 private final Map<String, Class<?>> setterParams = new Hashtable<String,Class<?>>(); 2765 2766 private boolean bitCheck(String name,int...bits){ 2767 Integer id = rightIndexs.get(name); 2768 return (null == id)?false:BeanConverterUtils.bitCheck(id.intValue(),bits); 2769 } 2770 private int[] bitOR(String name,int... bits){ 2771 return BeanConverterUtils.bitOR(rightIndexs.get(name),bits); 2772 } 2773 private void getGetter(String name){ 2774 try{ 2775 methods.put(name,rightType.getMethod(name)); 2776 }catch(NoSuchMethodException e){} 2777 } 2778 private void getSetter(String name, Class<?>...types) throws NoSuchMethodException{ 2779 for(Class<?>paramType:types){ 2780 try{ 2781 methods.put(name,rightType.getMethod(name,paramType)); 2782 setterParams.put(name, paramType); 2783 return; 2784 }catch(NoSuchMethodException e){ 2785 continue; 2786 } 2787 } 2788 throw new NoSuchMethodException(); 2789 } 2790 private void getSetterNoThrow(String name, Class<?>...types){ 2791 try{ 2792 getSetter(name,types); 2793 }catch(NoSuchMethodException e){} 2794 } 2795 /** 2796 * usage: <pre>new PersonBeanConverter<Model>(javaFields){};</pre> 2797 * @param javaFields a comma splice string,including all field name of R_PERSON,<br> 2798 * if null or empty, use default string:{@link Constant#FL_PERSON_JAVA_FIELDS} 2799 */ 2800 public PersonBeanConverter(String javaFields){ 2801 super(); 2802 init(javaFields); 2803 } 2804 /** @see #PersonBeanConverter(String) */ 2805 public PersonBeanConverter(){ 2806 this(null); 2807 } 2808 /** 2809 * constructor 2810 * @param leftClass 2811 * @param rightClass 2812 * @param javaFields see also {@link #PersonBeanConverter(String)} 2813 */ 2814 public PersonBeanConverter (Class<PersonBean> leftClass, Class<R_PERSON> rightClass,String javaFields){ 2815 super(leftClass,rightClass); 2816 init(javaFields); 2817 } 2818 /** @see #PersonBeanConverter(Class,Class,String) */ 2819 public PersonBeanConverter (Class<PersonBean> leftClass, Class<R_PERSON> rightClass){ 2820 this(leftClass,rightClass,null); 2821 } 2822 private void init(String javaFields){ 2823 if(null == javaFields || javaFields.isEmpty()){ 2824 javaFields = FL_PERSON_JAVA_FIELDS; 2825 } 2826 String []rightFields = javaFields.split(","); 2827 for(int i = 0 ; i < rightFields.length; ++i){ 2828 String field = rightFields[i].trim(); 2829 if(!field.matches("\\w+")){ 2830 throw new IllegalArgumentException("invalid 'javaFields':" + javaFields); 2831 } 2832 rightIndexs.put(field,i); 2833 } 2834 try{ 2835 methods.put(IS_NEW,rightType.getMethod(IS_NEW)); 2836 methods.put(GET_INITIALIZED,rightType.getMethod(GET_INITIALIZED)); 2837 getSetter(SET_NEW,boolean.class); 2838 if(rightIndexs.size() > STATE_BIT_NUM){ 2839 getSetter(SET_INITIALIZED,int[].class,List.class); 2840 }else{ 2841 getSetter(SET_INITIALIZED,int.class); 2842 } 2843 getGetter(GET_MODIFIED); 2844 if(rightIndexs.size() > STATE_BIT_NUM){ 2845 getSetter(SET_MODIFIED,int[].class,List.class); 2846 }else{ 2847 getSetter(SET_MODIFIED,int.class); 2848 } 2849 }catch(NoSuchMethodException e){ 2850 throw new RuntimeException(e); 2851 } 2852 2853 getGetter(Column.id.getter); 2854 getSetterNoThrow(Column.id.setter,Integer.class,int.class); 2855 getGetter(Column.groupId.getter); 2856 getSetterNoThrow(Column.groupId.setter,Integer.class,int.class); 2857 getGetter(Column.name.getter); 2858 getSetterNoThrow(Column.name.setter,String.class); 2859 getGetter(Column.sex.getter); 2860 getSetterNoThrow(Column.sex.setter,Integer.class,int.class); 2861 getGetter(Column.rank.getter); 2862 getSetterNoThrow(Column.rank.setter,Integer.class,int.class); 2863 getGetter(Column.password.getter); 2864 getSetterNoThrow(Column.password.setter,String.class); 2865 getGetter(Column.birthdate.getter); 2866 getSetterNoThrow(Column.birthdate.setter,java.util.Date.class,Long.class,long.class); 2867 getGetter(Column.mobilePhone.getter); 2868 getSetterNoThrow(Column.mobilePhone.setter,String.class); 2869 getGetter(Column.papersType.getter); 2870 getSetterNoThrow(Column.papersType.setter,Integer.class,int.class); 2871 getGetter(Column.papersNum.getter); 2872 getSetterNoThrow(Column.papersNum.setter,String.class); 2873 getGetter(Column.imageMd5.getter); 2874 getSetterNoThrow(Column.imageMd5.setter,String.class); 2875 getGetter(Column.expiryDate.getter); 2876 getSetterNoThrow(Column.expiryDate.setter,java.util.Date.class,Long.class,long.class); 2877 getGetter(Column.activatedDate.getter); 2878 getSetterNoThrow(Column.activatedDate.setter,java.util.Date.class,Long.class,long.class); 2879 getGetter(Column.remark.getter); 2880 getSetterNoThrow(Column.remark.setter,String.class); 2881 getGetter(Column.extBin.getter); 2882 getSetterNoThrow(Column.extBin.setter,java.nio.ByteBuffer.class,byte[].class); 2883 getGetter(Column.extTxt.getter); 2884 getSetterNoThrow(Column.extTxt.setter,String.class); 2885 getGetter(Column.createTime.getter); 2886 getSetterNoThrow(Column.createTime.setter,java.util.Date.class,Long.class,long.class); 2887 getGetter(Column.updateTime.getter); 2888 getSetterNoThrow(Column.updateTime.setter,java.util.Date.class,Long.class,long.class); 2889 } 2890 @Override 2891 protected void doFromRight(PersonBean left, R_PERSON right) { 2892 try{ 2893 Method getterMethod; 2894 left.resetIsModified(); 2895 int selfModified = 0; 2896 int[] initialized; 2897 int[] modified; 2898 if(rightIndexs.size() > STATE_BIT_NUM){ 2899 initialized = (int[])methods.get(GET_INITIALIZED).invoke(right); 2900 modified = (int[])methods.get(GET_MODIFIED).invoke(right); 2901 }else{ 2902 initialized = new int[]{(Integer)methods.get(GET_INITIALIZED).invoke(right)}; 2903 modified = new int[]{(Integer)methods.get(GET_MODIFIED).invoke(right)}; 2904 } 2905 if( bitCheck(Column.id.name(),initialized) && (null != (getterMethod = methods.get(Column.id.getter)))){ 2906 left.setId(cast(Integer.class,getterMethod.invoke(right))); 2907 if(bitCheck(Column.id.name(),modified)){ 2908 selfModified |= FL_PERSON_ID_ID_MASK; 2909 } 2910 } 2911 if( bitCheck(Column.groupId.name(),initialized) && (null != (getterMethod = methods.get(Column.groupId.getter)))){ 2912 left.setGroupId(cast(Integer.class,getterMethod.invoke(right))); 2913 if(bitCheck(Column.groupId.name(),modified)){ 2914 selfModified |= FL_PERSON_ID_GROUP_ID_MASK; 2915 } 2916 } 2917 if( bitCheck(Column.name.name(),initialized) && (null != (getterMethod = methods.get(Column.name.getter)))){ 2918 left.setName(cast(String.class,getterMethod.invoke(right))); 2919 if(bitCheck(Column.name.name(),modified)){ 2920 selfModified |= FL_PERSON_ID_NAME_MASK; 2921 } 2922 } 2923 if( bitCheck(Column.sex.name(),initialized) && (null != (getterMethod = methods.get(Column.sex.getter)))){ 2924 left.setSex(cast(Integer.class,getterMethod.invoke(right))); 2925 if(bitCheck(Column.sex.name(),modified)){ 2926 selfModified |= FL_PERSON_ID_SEX_MASK; 2927 } 2928 } 2929 if( bitCheck(Column.rank.name(),initialized) && (null != (getterMethod = methods.get(Column.rank.getter)))){ 2930 left.setRank(cast(Integer.class,getterMethod.invoke(right))); 2931 if(bitCheck(Column.rank.name(),modified)){ 2932 selfModified |= FL_PERSON_ID_RANK_MASK; 2933 } 2934 } 2935 if( bitCheck(Column.password.name(),initialized) && (null != (getterMethod = methods.get(Column.password.getter)))){ 2936 left.setPassword(cast(String.class,getterMethod.invoke(right))); 2937 if(bitCheck(Column.password.name(),modified)){ 2938 selfModified |= FL_PERSON_ID_PASSWORD_MASK; 2939 } 2940 } 2941 if( bitCheck(Column.birthdate.name(),initialized) && (null != (getterMethod = methods.get(Column.birthdate.getter)))){ 2942 left.setBirthdate(cast(java.util.Date.class,getterMethod.invoke(right))); 2943 if(bitCheck(Column.birthdate.name(),modified)){ 2944 selfModified |= FL_PERSON_ID_BIRTHDATE_MASK; 2945 } 2946 } 2947 if( bitCheck(Column.mobilePhone.name(),initialized) && (null != (getterMethod = methods.get(Column.mobilePhone.getter)))){ 2948 left.setMobilePhone(cast(String.class,getterMethod.invoke(right))); 2949 if(bitCheck(Column.mobilePhone.name(),modified)){ 2950 selfModified |= FL_PERSON_ID_MOBILE_PHONE_MASK; 2951 } 2952 } 2953 if( bitCheck(Column.papersType.name(),initialized) && (null != (getterMethod = methods.get(Column.papersType.getter)))){ 2954 left.setPapersType(cast(Integer.class,getterMethod.invoke(right))); 2955 if(bitCheck(Column.papersType.name(),modified)){ 2956 selfModified |= FL_PERSON_ID_PAPERS_TYPE_MASK; 2957 } 2958 } 2959 if( bitCheck(Column.papersNum.name(),initialized) && (null != (getterMethod = methods.get(Column.papersNum.getter)))){ 2960 left.setPapersNum(cast(String.class,getterMethod.invoke(right))); 2961 if(bitCheck(Column.papersNum.name(),modified)){ 2962 selfModified |= FL_PERSON_ID_PAPERS_NUM_MASK; 2963 } 2964 } 2965 if( bitCheck(Column.imageMd5.name(),initialized) && (null != (getterMethod = methods.get(Column.imageMd5.getter)))){ 2966 left.setImageMd5(cast(String.class,getterMethod.invoke(right))); 2967 if(bitCheck(Column.imageMd5.name(),modified)){ 2968 selfModified |= FL_PERSON_ID_IMAGE_MD5_MASK; 2969 } 2970 } 2971 if( bitCheck(Column.expiryDate.name(),initialized) && (null != (getterMethod = methods.get(Column.expiryDate.getter)))){ 2972 left.setExpiryDate(cast(java.util.Date.class,getterMethod.invoke(right))); 2973 if(bitCheck(Column.expiryDate.name(),modified)){ 2974 selfModified |= FL_PERSON_ID_EXPIRY_DATE_MASK; 2975 } 2976 } 2977 if( bitCheck(Column.activatedDate.name(),initialized) && (null != (getterMethod = methods.get(Column.activatedDate.getter)))){ 2978 left.setActivatedDate(cast(java.util.Date.class,getterMethod.invoke(right))); 2979 if(bitCheck(Column.activatedDate.name(),modified)){ 2980 selfModified |= FL_PERSON_ID_ACTIVATED_DATE_MASK; 2981 } 2982 } 2983 if( bitCheck(Column.remark.name(),initialized) && (null != (getterMethod = methods.get(Column.remark.getter)))){ 2984 left.setRemark(cast(String.class,getterMethod.invoke(right))); 2985 if(bitCheck(Column.remark.name(),modified)){ 2986 selfModified |= FL_PERSON_ID_REMARK_MASK; 2987 } 2988 } 2989 if( bitCheck(Column.extBin.name(),initialized) && (null != (getterMethod = methods.get(Column.extBin.getter)))){ 2990 left.setExtBin(cast(java.nio.ByteBuffer.class,getterMethod.invoke(right))); 2991 if(bitCheck(Column.extBin.name(),modified)){ 2992 selfModified |= FL_PERSON_ID_EXT_BIN_MASK; 2993 } 2994 } 2995 if( bitCheck(Column.extTxt.name(),initialized) && (null != (getterMethod = methods.get(Column.extTxt.getter)))){ 2996 left.setExtTxt(cast(String.class,getterMethod.invoke(right))); 2997 if(bitCheck(Column.extTxt.name(),modified)){ 2998 selfModified |= FL_PERSON_ID_EXT_TXT_MASK; 2999 } 3000 } 3001 if( bitCheck(Column.createTime.name(),initialized) && (null != (getterMethod = methods.get(Column.createTime.getter)))){ 3002 left.setCreateTime(cast(java.util.Date.class,getterMethod.invoke(right))); 3003 if(bitCheck(Column.createTime.name(),modified)){ 3004 selfModified |= FL_PERSON_ID_CREATE_TIME_MASK; 3005 } 3006 } 3007 if( bitCheck(Column.updateTime.name(),initialized) && (null != (getterMethod = methods.get(Column.updateTime.getter)))){ 3008 left.setUpdateTime(cast(java.util.Date.class,getterMethod.invoke(right))); 3009 if(bitCheck(Column.updateTime.name(),modified)){ 3010 selfModified |= FL_PERSON_ID_UPDATE_TIME_MASK; 3011 } 3012 } 3013 left.isNew((Boolean)methods.get(IS_NEW).invoke(right)); 3014 left.setModified(selfModified); 3015 }catch(RuntimeException e){ 3016 throw e; 3017 }catch(Exception e){ 3018 throw new RuntimeException(e); 3019 } 3020 } 3021 3022 @Override 3023 protected void doToRight(PersonBean left, R_PERSON right) { 3024 try{ 3025 Method setterMethod; 3026 int[] initialized = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 3027 int[] modified = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 3028 Arrays.fill(initialized, 0); 3029 Arrays.fill(modified, 0); 3030 if(null != (setterMethod = methods.get(Column.id.setter)) && left.checkIdInitialized()){ 3031 try{ 3032 setterMethod.invoke(right,cast(setterParams.get(Column.id.setter),left.getId())); 3033 bitOR(Column.id.name(),initialized); 3034 if(left.checkIdModified()){ 3035 bitOR(Column.id.name(),modified); 3036 } 3037 }catch(NullCastPrimitiveException e){} 3038 } 3039 if(null != (setterMethod = methods.get(Column.groupId.setter)) && left.checkGroupIdInitialized()){ 3040 try{ 3041 setterMethod.invoke(right,cast(setterParams.get(Column.groupId.setter),left.getGroupId())); 3042 bitOR(Column.groupId.name(),initialized); 3043 if(left.checkGroupIdModified()){ 3044 bitOR(Column.groupId.name(),modified); 3045 } 3046 }catch(NullCastPrimitiveException e){} 3047 } 3048 if(null != (setterMethod = methods.get(Column.name.setter)) && left.checkNameInitialized()){ 3049 try{ 3050 setterMethod.invoke(right,cast(setterParams.get(Column.name.setter),left.getName())); 3051 bitOR(Column.name.name(),initialized); 3052 if(left.checkNameModified()){ 3053 bitOR(Column.name.name(),modified); 3054 } 3055 }catch(NullCastPrimitiveException e){} 3056 } 3057 if(null != (setterMethod = methods.get(Column.sex.setter)) && left.checkSexInitialized()){ 3058 try{ 3059 setterMethod.invoke(right,cast(setterParams.get(Column.sex.setter),left.getSex())); 3060 bitOR(Column.sex.name(),initialized); 3061 if(left.checkSexModified()){ 3062 bitOR(Column.sex.name(),modified); 3063 } 3064 }catch(NullCastPrimitiveException e){} 3065 } 3066 if(null != (setterMethod = methods.get(Column.rank.setter)) && left.checkRankInitialized()){ 3067 try{ 3068 setterMethod.invoke(right,cast(setterParams.get(Column.rank.setter),left.getRank())); 3069 bitOR(Column.rank.name(),initialized); 3070 if(left.checkRankModified()){ 3071 bitOR(Column.rank.name(),modified); 3072 } 3073 }catch(NullCastPrimitiveException e){} 3074 } 3075 if(null != (setterMethod = methods.get(Column.password.setter)) && left.checkPasswordInitialized()){ 3076 try{ 3077 setterMethod.invoke(right,cast(setterParams.get(Column.password.setter),left.getPassword())); 3078 bitOR(Column.password.name(),initialized); 3079 if(left.checkPasswordModified()){ 3080 bitOR(Column.password.name(),modified); 3081 } 3082 }catch(NullCastPrimitiveException e){} 3083 } 3084 if(null != (setterMethod = methods.get(Column.birthdate.setter)) && left.checkBirthdateInitialized()){ 3085 try{ 3086 setterMethod.invoke(right,cast(setterParams.get(Column.birthdate.setter),left.getBirthdate())); 3087 bitOR(Column.birthdate.name(),initialized); 3088 if(left.checkBirthdateModified()){ 3089 bitOR(Column.birthdate.name(),modified); 3090 } 3091 }catch(NullCastPrimitiveException e){} 3092 } 3093 if(null != (setterMethod = methods.get(Column.mobilePhone.setter)) && left.checkMobilePhoneInitialized()){ 3094 try{ 3095 setterMethod.invoke(right,cast(setterParams.get(Column.mobilePhone.setter),left.getMobilePhone())); 3096 bitOR(Column.mobilePhone.name(),initialized); 3097 if(left.checkMobilePhoneModified()){ 3098 bitOR(Column.mobilePhone.name(),modified); 3099 } 3100 }catch(NullCastPrimitiveException e){} 3101 } 3102 if(null != (setterMethod = methods.get(Column.papersType.setter)) && left.checkPapersTypeInitialized()){ 3103 try{ 3104 setterMethod.invoke(right,cast(setterParams.get(Column.papersType.setter),left.getPapersType())); 3105 bitOR(Column.papersType.name(),initialized); 3106 if(left.checkPapersTypeModified()){ 3107 bitOR(Column.papersType.name(),modified); 3108 } 3109 }catch(NullCastPrimitiveException e){} 3110 } 3111 if(null != (setterMethod = methods.get(Column.papersNum.setter)) && left.checkPapersNumInitialized()){ 3112 try{ 3113 setterMethod.invoke(right,cast(setterParams.get(Column.papersNum.setter),left.getPapersNum())); 3114 bitOR(Column.papersNum.name(),initialized); 3115 if(left.checkPapersNumModified()){ 3116 bitOR(Column.papersNum.name(),modified); 3117 } 3118 }catch(NullCastPrimitiveException e){} 3119 } 3120 if(null != (setterMethod = methods.get(Column.imageMd5.setter)) && left.checkImageMd5Initialized()){ 3121 try{ 3122 setterMethod.invoke(right,cast(setterParams.get(Column.imageMd5.setter),left.getImageMd5())); 3123 bitOR(Column.imageMd5.name(),initialized); 3124 if(left.checkImageMd5Modified()){ 3125 bitOR(Column.imageMd5.name(),modified); 3126 } 3127 }catch(NullCastPrimitiveException e){} 3128 } 3129 if(null != (setterMethod = methods.get(Column.expiryDate.setter)) && left.checkExpiryDateInitialized()){ 3130 try{ 3131 setterMethod.invoke(right,cast(setterParams.get(Column.expiryDate.setter),left.getExpiryDate())); 3132 bitOR(Column.expiryDate.name(),initialized); 3133 if(left.checkExpiryDateModified()){ 3134 bitOR(Column.expiryDate.name(),modified); 3135 } 3136 }catch(NullCastPrimitiveException e){} 3137 } 3138 if(null != (setterMethod = methods.get(Column.activatedDate.setter)) && left.checkActivatedDateInitialized()){ 3139 try{ 3140 setterMethod.invoke(right,cast(setterParams.get(Column.activatedDate.setter),left.getActivatedDate())); 3141 bitOR(Column.activatedDate.name(),initialized); 3142 if(left.checkActivatedDateModified()){ 3143 bitOR(Column.activatedDate.name(),modified); 3144 } 3145 }catch(NullCastPrimitiveException e){} 3146 } 3147 if(null != (setterMethod = methods.get(Column.remark.setter)) && left.checkRemarkInitialized()){ 3148 try{ 3149 setterMethod.invoke(right,cast(setterParams.get(Column.remark.setter),left.getRemark())); 3150 bitOR(Column.remark.name(),initialized); 3151 if(left.checkRemarkModified()){ 3152 bitOR(Column.remark.name(),modified); 3153 } 3154 }catch(NullCastPrimitiveException e){} 3155 } 3156 if(null != (setterMethod = methods.get(Column.extBin.setter)) && left.checkExtBinInitialized()){ 3157 try{ 3158 setterMethod.invoke(right,cast(setterParams.get(Column.extBin.setter),left.getExtBin())); 3159 bitOR(Column.extBin.name(),initialized); 3160 if(left.checkExtBinModified()){ 3161 bitOR(Column.extBin.name(),modified); 3162 } 3163 }catch(NullCastPrimitiveException e){} 3164 } 3165 if(null != (setterMethod = methods.get(Column.extTxt.setter)) && left.checkExtTxtInitialized()){ 3166 try{ 3167 setterMethod.invoke(right,cast(setterParams.get(Column.extTxt.setter),left.getExtTxt())); 3168 bitOR(Column.extTxt.name(),initialized); 3169 if(left.checkExtTxtModified()){ 3170 bitOR(Column.extTxt.name(),modified); 3171 } 3172 }catch(NullCastPrimitiveException e){} 3173 } 3174// IGNORE field fl_person.create_time , controlled by 'general.beanconverter.tonative.ignore' in properties file 3175/* 3176 if(null != (setterMethod = methods.get(Column.createTime.setter)) && left.checkCreateTimeInitialized()){ 3177 try{ 3178 setterMethod.invoke(right,cast(setterParams.get(Column.createTime.setter),left.getCreateTime())); 3179 bitOR(Column.createTime.name(),initialized); 3180 if(left.checkCreateTimeModified()){ 3181 bitOR(Column.createTime.name(),modified); 3182 } 3183 }catch(NullCastPrimitiveException e){} 3184 } 3185*/ 3186// IGNORE field fl_person.update_time , controlled by 'general.beanconverter.tonative.ignore' in properties file 3187/* 3188 if(null != (setterMethod = methods.get(Column.updateTime.setter)) && left.checkUpdateTimeInitialized()){ 3189 try{ 3190 setterMethod.invoke(right,cast(setterParams.get(Column.updateTime.setter),left.getUpdateTime())); 3191 bitOR(Column.updateTime.name(),initialized); 3192 if(left.checkUpdateTimeModified()){ 3193 bitOR(Column.updateTime.name(),modified); 3194 } 3195 }catch(NullCastPrimitiveException e){} 3196 } 3197*/ 3198 if(null != (setterMethod = methods.get(SET_MODIFIED))){ 3199 if( initialized.length > 1){ 3200 setterMethod.invoke(right,cast(setterParams.get(SET_MODIFIED),initialized)); 3201 }else{ 3202 setterMethod.invoke(right,initialized[0]); 3203 } 3204 } 3205 methods.get(SET_NEW).invoke(right,left.isNew()); 3206 if( initialized.length > 1){ 3207 methods.get(SET_INITIALIZED).invoke(right,cast(setterParams.get(SET_INITIALIZED),initialized)); 3208 methods.get(SET_MODIFIED).invoke(right,cast(setterParams.get(SET_MODIFIED),modified)); 3209 }else{ 3210 methods.get(SET_INITIALIZED).invoke(right,initialized[0]); 3211 methods.get(SET_MODIFIED).invoke(right,modified[0]); 3212 } 3213 }catch(RuntimeException e){ 3214 throw e; 3215 }catch(Exception e){ 3216 throw new RuntimeException(e); 3217 } 3218 } 3219 }; 3220 /** 3221 * implementation of {@link IBeanConverter} by reflect<br> 3222 * generic type converter between {@link PersonGroupBean} and R_PERSONGROUP <br> 3223 * @author guyadong 3224 * @param <R_PERSONGROUP> right type 3225 * 3226 */ 3227 public static class PersonGroupBeanConverter<R_PERSONGROUP> extends IBeanConverter.AbstractHandle<PersonGroupBean,R_PERSONGROUP>{ 3228 static enum Column{ 3229 /** column method info */ 3230 id("getId","setId"), 3231 name("getName","setName"), 3232 leaf("getLeaf","setLeaf"), 3233 parent("getParent","setParent"), 3234 rootGroup("getRootGroup","setRootGroup"), 3235 remark("getRemark","setRemark"), 3236 extBin("getExtBin","setExtBin"), 3237 extTxt("getExtTxt","setExtTxt"), 3238 createTime("getCreateTime","setCreateTime"), 3239 updateTime("getUpdateTime","setUpdateTime"); 3240 final String getter; 3241 final String setter; 3242 Column(String getter,String setter){ 3243 this.getter = setter; 3244 this.setter = setter; 3245 } 3246 } 3247 private final Map<String,Method> methods = new Hashtable<String,Method>(); 3248 private final Map<String,Integer> rightIndexs = new Hashtable<String,Integer>(); 3249 private final Map<String, Class<?>> setterParams = new Hashtable<String,Class<?>>(); 3250 3251 private boolean bitCheck(String name,int...bits){ 3252 Integer id = rightIndexs.get(name); 3253 return (null == id)?false:BeanConverterUtils.bitCheck(id.intValue(),bits); 3254 } 3255 private int[] bitOR(String name,int... bits){ 3256 return BeanConverterUtils.bitOR(rightIndexs.get(name),bits); 3257 } 3258 private void getGetter(String name){ 3259 try{ 3260 methods.put(name,rightType.getMethod(name)); 3261 }catch(NoSuchMethodException e){} 3262 } 3263 private void getSetter(String name, Class<?>...types) throws NoSuchMethodException{ 3264 for(Class<?>paramType:types){ 3265 try{ 3266 methods.put(name,rightType.getMethod(name,paramType)); 3267 setterParams.put(name, paramType); 3268 return; 3269 }catch(NoSuchMethodException e){ 3270 continue; 3271 } 3272 } 3273 throw new NoSuchMethodException(); 3274 } 3275 private void getSetterNoThrow(String name, Class<?>...types){ 3276 try{ 3277 getSetter(name,types); 3278 }catch(NoSuchMethodException e){} 3279 } 3280 /** 3281 * usage: <pre>new PersonGroupBeanConverter<Model>(javaFields){};</pre> 3282 * @param javaFields a comma splice string,including all field name of R_PERSONGROUP,<br> 3283 * if null or empty, use default string:{@link Constant#FL_PERSON_GROUP_JAVA_FIELDS} 3284 */ 3285 public PersonGroupBeanConverter(String javaFields){ 3286 super(); 3287 init(javaFields); 3288 } 3289 /** @see #PersonGroupBeanConverter(String) */ 3290 public PersonGroupBeanConverter(){ 3291 this(null); 3292 } 3293 /** 3294 * constructor 3295 * @param leftClass 3296 * @param rightClass 3297 * @param javaFields see also {@link #PersonGroupBeanConverter(String)} 3298 */ 3299 public PersonGroupBeanConverter (Class<PersonGroupBean> leftClass, Class<R_PERSONGROUP> rightClass,String javaFields){ 3300 super(leftClass,rightClass); 3301 init(javaFields); 3302 } 3303 /** @see #PersonGroupBeanConverter(Class,Class,String) */ 3304 public PersonGroupBeanConverter (Class<PersonGroupBean> leftClass, Class<R_PERSONGROUP> rightClass){ 3305 this(leftClass,rightClass,null); 3306 } 3307 private void init(String javaFields){ 3308 if(null == javaFields || javaFields.isEmpty()){ 3309 javaFields = FL_PERSON_GROUP_JAVA_FIELDS; 3310 } 3311 String []rightFields = javaFields.split(","); 3312 for(int i = 0 ; i < rightFields.length; ++i){ 3313 String field = rightFields[i].trim(); 3314 if(!field.matches("\\w+")){ 3315 throw new IllegalArgumentException("invalid 'javaFields':" + javaFields); 3316 } 3317 rightIndexs.put(field,i); 3318 } 3319 try{ 3320 methods.put(IS_NEW,rightType.getMethod(IS_NEW)); 3321 methods.put(GET_INITIALIZED,rightType.getMethod(GET_INITIALIZED)); 3322 getSetter(SET_NEW,boolean.class); 3323 if(rightIndexs.size() > STATE_BIT_NUM){ 3324 getSetter(SET_INITIALIZED,int[].class,List.class); 3325 }else{ 3326 getSetter(SET_INITIALIZED,int.class); 3327 } 3328 getGetter(GET_MODIFIED); 3329 if(rightIndexs.size() > STATE_BIT_NUM){ 3330 getSetter(SET_MODIFIED,int[].class,List.class); 3331 }else{ 3332 getSetter(SET_MODIFIED,int.class); 3333 } 3334 }catch(NoSuchMethodException e){ 3335 throw new RuntimeException(e); 3336 } 3337 3338 getGetter(Column.id.getter); 3339 getSetterNoThrow(Column.id.setter,Integer.class,int.class); 3340 getGetter(Column.name.getter); 3341 getSetterNoThrow(Column.name.setter,String.class); 3342 getGetter(Column.leaf.getter); 3343 getSetterNoThrow(Column.leaf.setter,Integer.class,int.class); 3344 getGetter(Column.parent.getter); 3345 getSetterNoThrow(Column.parent.setter,Integer.class,int.class); 3346 getGetter(Column.rootGroup.getter); 3347 getSetterNoThrow(Column.rootGroup.setter,Integer.class,int.class); 3348 getGetter(Column.remark.getter); 3349 getSetterNoThrow(Column.remark.setter,String.class); 3350 getGetter(Column.extBin.getter); 3351 getSetterNoThrow(Column.extBin.setter,java.nio.ByteBuffer.class,byte[].class); 3352 getGetter(Column.extTxt.getter); 3353 getSetterNoThrow(Column.extTxt.setter,String.class); 3354 getGetter(Column.createTime.getter); 3355 getSetterNoThrow(Column.createTime.setter,java.util.Date.class,Long.class,long.class); 3356 getGetter(Column.updateTime.getter); 3357 getSetterNoThrow(Column.updateTime.setter,java.util.Date.class,Long.class,long.class); 3358 } 3359 @Override 3360 protected void doFromRight(PersonGroupBean left, R_PERSONGROUP right) { 3361 try{ 3362 Method getterMethod; 3363 left.resetIsModified(); 3364 int selfModified = 0; 3365 int[] initialized; 3366 int[] modified; 3367 if(rightIndexs.size() > STATE_BIT_NUM){ 3368 initialized = (int[])methods.get(GET_INITIALIZED).invoke(right); 3369 modified = (int[])methods.get(GET_MODIFIED).invoke(right); 3370 }else{ 3371 initialized = new int[]{(Integer)methods.get(GET_INITIALIZED).invoke(right)}; 3372 modified = new int[]{(Integer)methods.get(GET_MODIFIED).invoke(right)}; 3373 } 3374 if( bitCheck(Column.id.name(),initialized) && (null != (getterMethod = methods.get(Column.id.getter)))){ 3375 left.setId(cast(Integer.class,getterMethod.invoke(right))); 3376 if(bitCheck(Column.id.name(),modified)){ 3377 selfModified |= FL_PERSON_GROUP_ID_ID_MASK; 3378 } 3379 } 3380 if( bitCheck(Column.name.name(),initialized) && (null != (getterMethod = methods.get(Column.name.getter)))){ 3381 left.setName(cast(String.class,getterMethod.invoke(right))); 3382 if(bitCheck(Column.name.name(),modified)){ 3383 selfModified |= FL_PERSON_GROUP_ID_NAME_MASK; 3384 } 3385 } 3386 if( bitCheck(Column.leaf.name(),initialized) && (null != (getterMethod = methods.get(Column.leaf.getter)))){ 3387 left.setLeaf(cast(Integer.class,getterMethod.invoke(right))); 3388 if(bitCheck(Column.leaf.name(),modified)){ 3389 selfModified |= FL_PERSON_GROUP_ID_LEAF_MASK; 3390 } 3391 } 3392 if( bitCheck(Column.parent.name(),initialized) && (null != (getterMethod = methods.get(Column.parent.getter)))){ 3393 left.setParent(cast(Integer.class,getterMethod.invoke(right))); 3394 if(bitCheck(Column.parent.name(),modified)){ 3395 selfModified |= FL_PERSON_GROUP_ID_PARENT_MASK; 3396 } 3397 } 3398 if( bitCheck(Column.rootGroup.name(),initialized) && (null != (getterMethod = methods.get(Column.rootGroup.getter)))){ 3399 left.setRootGroup(cast(Integer.class,getterMethod.invoke(right))); 3400 if(bitCheck(Column.rootGroup.name(),modified)){ 3401 selfModified |= FL_PERSON_GROUP_ID_ROOT_GROUP_MASK; 3402 } 3403 } 3404 if( bitCheck(Column.remark.name(),initialized) && (null != (getterMethod = methods.get(Column.remark.getter)))){ 3405 left.setRemark(cast(String.class,getterMethod.invoke(right))); 3406 if(bitCheck(Column.remark.name(),modified)){ 3407 selfModified |= FL_PERSON_GROUP_ID_REMARK_MASK; 3408 } 3409 } 3410 if( bitCheck(Column.extBin.name(),initialized) && (null != (getterMethod = methods.get(Column.extBin.getter)))){ 3411 left.setExtBin(cast(java.nio.ByteBuffer.class,getterMethod.invoke(right))); 3412 if(bitCheck(Column.extBin.name(),modified)){ 3413 selfModified |= FL_PERSON_GROUP_ID_EXT_BIN_MASK; 3414 } 3415 } 3416 if( bitCheck(Column.extTxt.name(),initialized) && (null != (getterMethod = methods.get(Column.extTxt.getter)))){ 3417 left.setExtTxt(cast(String.class,getterMethod.invoke(right))); 3418 if(bitCheck(Column.extTxt.name(),modified)){ 3419 selfModified |= FL_PERSON_GROUP_ID_EXT_TXT_MASK; 3420 } 3421 } 3422 if( bitCheck(Column.createTime.name(),initialized) && (null != (getterMethod = methods.get(Column.createTime.getter)))){ 3423 left.setCreateTime(cast(java.util.Date.class,getterMethod.invoke(right))); 3424 if(bitCheck(Column.createTime.name(),modified)){ 3425 selfModified |= FL_PERSON_GROUP_ID_CREATE_TIME_MASK; 3426 } 3427 } 3428 if( bitCheck(Column.updateTime.name(),initialized) && (null != (getterMethod = methods.get(Column.updateTime.getter)))){ 3429 left.setUpdateTime(cast(java.util.Date.class,getterMethod.invoke(right))); 3430 if(bitCheck(Column.updateTime.name(),modified)){ 3431 selfModified |= FL_PERSON_GROUP_ID_UPDATE_TIME_MASK; 3432 } 3433 } 3434 left.isNew((Boolean)methods.get(IS_NEW).invoke(right)); 3435 left.setModified(selfModified); 3436 }catch(RuntimeException e){ 3437 throw e; 3438 }catch(Exception e){ 3439 throw new RuntimeException(e); 3440 } 3441 } 3442 3443 @Override 3444 protected void doToRight(PersonGroupBean left, R_PERSONGROUP right) { 3445 try{ 3446 Method setterMethod; 3447 int[] initialized = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 3448 int[] modified = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 3449 Arrays.fill(initialized, 0); 3450 Arrays.fill(modified, 0); 3451 if(null != (setterMethod = methods.get(Column.id.setter)) && left.checkIdInitialized()){ 3452 try{ 3453 setterMethod.invoke(right,cast(setterParams.get(Column.id.setter),left.getId())); 3454 bitOR(Column.id.name(),initialized); 3455 if(left.checkIdModified()){ 3456 bitOR(Column.id.name(),modified); 3457 } 3458 }catch(NullCastPrimitiveException e){} 3459 } 3460 if(null != (setterMethod = methods.get(Column.name.setter)) && left.checkNameInitialized()){ 3461 try{ 3462 setterMethod.invoke(right,cast(setterParams.get(Column.name.setter),left.getName())); 3463 bitOR(Column.name.name(),initialized); 3464 if(left.checkNameModified()){ 3465 bitOR(Column.name.name(),modified); 3466 } 3467 }catch(NullCastPrimitiveException e){} 3468 } 3469 if(null != (setterMethod = methods.get(Column.leaf.setter)) && left.checkLeafInitialized()){ 3470 try{ 3471 setterMethod.invoke(right,cast(setterParams.get(Column.leaf.setter),left.getLeaf())); 3472 bitOR(Column.leaf.name(),initialized); 3473 if(left.checkLeafModified()){ 3474 bitOR(Column.leaf.name(),modified); 3475 } 3476 }catch(NullCastPrimitiveException e){} 3477 } 3478 if(null != (setterMethod = methods.get(Column.parent.setter)) && left.checkParentInitialized()){ 3479 try{ 3480 setterMethod.invoke(right,cast(setterParams.get(Column.parent.setter),left.getParent())); 3481 bitOR(Column.parent.name(),initialized); 3482 if(left.checkParentModified()){ 3483 bitOR(Column.parent.name(),modified); 3484 } 3485 }catch(NullCastPrimitiveException e){} 3486 } 3487 if(null != (setterMethod = methods.get(Column.rootGroup.setter)) && left.checkRootGroupInitialized()){ 3488 try{ 3489 setterMethod.invoke(right,cast(setterParams.get(Column.rootGroup.setter),left.getRootGroup())); 3490 bitOR(Column.rootGroup.name(),initialized); 3491 if(left.checkRootGroupModified()){ 3492 bitOR(Column.rootGroup.name(),modified); 3493 } 3494 }catch(NullCastPrimitiveException e){} 3495 } 3496 if(null != (setterMethod = methods.get(Column.remark.setter)) && left.checkRemarkInitialized()){ 3497 try{ 3498 setterMethod.invoke(right,cast(setterParams.get(Column.remark.setter),left.getRemark())); 3499 bitOR(Column.remark.name(),initialized); 3500 if(left.checkRemarkModified()){ 3501 bitOR(Column.remark.name(),modified); 3502 } 3503 }catch(NullCastPrimitiveException e){} 3504 } 3505 if(null != (setterMethod = methods.get(Column.extBin.setter)) && left.checkExtBinInitialized()){ 3506 try{ 3507 setterMethod.invoke(right,cast(setterParams.get(Column.extBin.setter),left.getExtBin())); 3508 bitOR(Column.extBin.name(),initialized); 3509 if(left.checkExtBinModified()){ 3510 bitOR(Column.extBin.name(),modified); 3511 } 3512 }catch(NullCastPrimitiveException e){} 3513 } 3514 if(null != (setterMethod = methods.get(Column.extTxt.setter)) && left.checkExtTxtInitialized()){ 3515 try{ 3516 setterMethod.invoke(right,cast(setterParams.get(Column.extTxt.setter),left.getExtTxt())); 3517 bitOR(Column.extTxt.name(),initialized); 3518 if(left.checkExtTxtModified()){ 3519 bitOR(Column.extTxt.name(),modified); 3520 } 3521 }catch(NullCastPrimitiveException e){} 3522 } 3523// IGNORE field fl_person_group.create_time , controlled by 'general.beanconverter.tonative.ignore' in properties file 3524/* 3525 if(null != (setterMethod = methods.get(Column.createTime.setter)) && left.checkCreateTimeInitialized()){ 3526 try{ 3527 setterMethod.invoke(right,cast(setterParams.get(Column.createTime.setter),left.getCreateTime())); 3528 bitOR(Column.createTime.name(),initialized); 3529 if(left.checkCreateTimeModified()){ 3530 bitOR(Column.createTime.name(),modified); 3531 } 3532 }catch(NullCastPrimitiveException e){} 3533 } 3534*/ 3535// IGNORE field fl_person_group.update_time , controlled by 'general.beanconverter.tonative.ignore' in properties file 3536/* 3537 if(null != (setterMethod = methods.get(Column.updateTime.setter)) && left.checkUpdateTimeInitialized()){ 3538 try{ 3539 setterMethod.invoke(right,cast(setterParams.get(Column.updateTime.setter),left.getUpdateTime())); 3540 bitOR(Column.updateTime.name(),initialized); 3541 if(left.checkUpdateTimeModified()){ 3542 bitOR(Column.updateTime.name(),modified); 3543 } 3544 }catch(NullCastPrimitiveException e){} 3545 } 3546*/ 3547 if(null != (setterMethod = methods.get(SET_MODIFIED))){ 3548 if( initialized.length > 1){ 3549 setterMethod.invoke(right,cast(setterParams.get(SET_MODIFIED),initialized)); 3550 }else{ 3551 setterMethod.invoke(right,initialized[0]); 3552 } 3553 } 3554 methods.get(SET_NEW).invoke(right,left.isNew()); 3555 if( initialized.length > 1){ 3556 methods.get(SET_INITIALIZED).invoke(right,cast(setterParams.get(SET_INITIALIZED),initialized)); 3557 methods.get(SET_MODIFIED).invoke(right,cast(setterParams.get(SET_MODIFIED),modified)); 3558 }else{ 3559 methods.get(SET_INITIALIZED).invoke(right,initialized[0]); 3560 methods.get(SET_MODIFIED).invoke(right,modified[0]); 3561 } 3562 }catch(RuntimeException e){ 3563 throw e; 3564 }catch(Exception e){ 3565 throw new RuntimeException(e); 3566 } 3567 } 3568 }; 3569 /** 3570 * implementation of {@link IBeanConverter} by reflect<br> 3571 * generic type converter between {@link StoreBean} and R_STORE <br> 3572 * @author guyadong 3573 * @param <R_STORE> right type 3574 * 3575 */ 3576 public static class StoreBeanConverter<R_STORE> extends IBeanConverter.AbstractHandle<StoreBean,R_STORE>{ 3577 static enum Column{ 3578 /** column method info */ 3579 md5("getMd5","setMd5"), 3580 encoding("getEncoding","setEncoding"), 3581 data("getData","setData"); 3582 final String getter; 3583 final String setter; 3584 Column(String getter,String setter){ 3585 this.getter = setter; 3586 this.setter = setter; 3587 } 3588 } 3589 private final Map<String,Method> methods = new Hashtable<String,Method>(); 3590 private final Map<String,Integer> rightIndexs = new Hashtable<String,Integer>(); 3591 private final Map<String, Class<?>> setterParams = new Hashtable<String,Class<?>>(); 3592 3593 private boolean bitCheck(String name,int...bits){ 3594 Integer id = rightIndexs.get(name); 3595 return (null == id)?false:BeanConverterUtils.bitCheck(id.intValue(),bits); 3596 } 3597 private int[] bitOR(String name,int... bits){ 3598 return BeanConverterUtils.bitOR(rightIndexs.get(name),bits); 3599 } 3600 private void getGetter(String name){ 3601 try{ 3602 methods.put(name,rightType.getMethod(name)); 3603 }catch(NoSuchMethodException e){} 3604 } 3605 private void getSetter(String name, Class<?>...types) throws NoSuchMethodException{ 3606 for(Class<?>paramType:types){ 3607 try{ 3608 methods.put(name,rightType.getMethod(name,paramType)); 3609 setterParams.put(name, paramType); 3610 return; 3611 }catch(NoSuchMethodException e){ 3612 continue; 3613 } 3614 } 3615 throw new NoSuchMethodException(); 3616 } 3617 private void getSetterNoThrow(String name, Class<?>...types){ 3618 try{ 3619 getSetter(name,types); 3620 }catch(NoSuchMethodException e){} 3621 } 3622 /** 3623 * usage: <pre>new StoreBeanConverter<Model>(javaFields){};</pre> 3624 * @param javaFields a comma splice string,including all field name of R_STORE,<br> 3625 * if null or empty, use default string:{@link Constant#FL_STORE_JAVA_FIELDS} 3626 */ 3627 public StoreBeanConverter(String javaFields){ 3628 super(); 3629 init(javaFields); 3630 } 3631 /** @see #StoreBeanConverter(String) */ 3632 public StoreBeanConverter(){ 3633 this(null); 3634 } 3635 /** 3636 * constructor 3637 * @param leftClass 3638 * @param rightClass 3639 * @param javaFields see also {@link #StoreBeanConverter(String)} 3640 */ 3641 public StoreBeanConverter (Class<StoreBean> leftClass, Class<R_STORE> rightClass,String javaFields){ 3642 super(leftClass,rightClass); 3643 init(javaFields); 3644 } 3645 /** @see #StoreBeanConverter(Class,Class,String) */ 3646 public StoreBeanConverter (Class<StoreBean> leftClass, Class<R_STORE> rightClass){ 3647 this(leftClass,rightClass,null); 3648 } 3649 private void init(String javaFields){ 3650 if(null == javaFields || javaFields.isEmpty()){ 3651 javaFields = FL_STORE_JAVA_FIELDS; 3652 } 3653 String []rightFields = javaFields.split(","); 3654 for(int i = 0 ; i < rightFields.length; ++i){ 3655 String field = rightFields[i].trim(); 3656 if(!field.matches("\\w+")){ 3657 throw new IllegalArgumentException("invalid 'javaFields':" + javaFields); 3658 } 3659 rightIndexs.put(field,i); 3660 } 3661 try{ 3662 methods.put(IS_NEW,rightType.getMethod(IS_NEW)); 3663 methods.put(GET_INITIALIZED,rightType.getMethod(GET_INITIALIZED)); 3664 getSetter(SET_NEW,boolean.class); 3665 if(rightIndexs.size() > STATE_BIT_NUM){ 3666 getSetter(SET_INITIALIZED,int[].class,List.class); 3667 }else{ 3668 getSetter(SET_INITIALIZED,int.class); 3669 } 3670 getGetter(GET_MODIFIED); 3671 if(rightIndexs.size() > STATE_BIT_NUM){ 3672 getSetter(SET_MODIFIED,int[].class,List.class); 3673 }else{ 3674 getSetter(SET_MODIFIED,int.class); 3675 } 3676 }catch(NoSuchMethodException e){ 3677 throw new RuntimeException(e); 3678 } 3679 3680 getGetter(Column.md5.getter); 3681 getSetterNoThrow(Column.md5.setter,String.class); 3682 getGetter(Column.encoding.getter); 3683 getSetterNoThrow(Column.encoding.setter,String.class); 3684 getGetter(Column.data.getter); 3685 getSetterNoThrow(Column.data.setter,java.nio.ByteBuffer.class,byte[].class); 3686 } 3687 @Override 3688 protected void doFromRight(StoreBean left, R_STORE right) { 3689 try{ 3690 Method getterMethod; 3691 left.resetIsModified(); 3692 int selfModified = 0; 3693 int[] initialized; 3694 int[] modified; 3695 if(rightIndexs.size() > STATE_BIT_NUM){ 3696 initialized = (int[])methods.get(GET_INITIALIZED).invoke(right); 3697 modified = (int[])methods.get(GET_MODIFIED).invoke(right); 3698 }else{ 3699 initialized = new int[]{(Integer)methods.get(GET_INITIALIZED).invoke(right)}; 3700 modified = new int[]{(Integer)methods.get(GET_MODIFIED).invoke(right)}; 3701 } 3702 if( bitCheck(Column.md5.name(),initialized) && (null != (getterMethod = methods.get(Column.md5.getter)))){ 3703 left.setMd5(cast(String.class,getterMethod.invoke(right))); 3704 if(bitCheck(Column.md5.name(),modified)){ 3705 selfModified |= FL_STORE_ID_MD5_MASK; 3706 } 3707 } 3708 if( bitCheck(Column.encoding.name(),initialized) && (null != (getterMethod = methods.get(Column.encoding.getter)))){ 3709 left.setEncoding(cast(String.class,getterMethod.invoke(right))); 3710 if(bitCheck(Column.encoding.name(),modified)){ 3711 selfModified |= FL_STORE_ID_ENCODING_MASK; 3712 } 3713 } 3714 if( bitCheck(Column.data.name(),initialized) && (null != (getterMethod = methods.get(Column.data.getter)))){ 3715 left.setData(cast(java.nio.ByteBuffer.class,getterMethod.invoke(right))); 3716 if(bitCheck(Column.data.name(),modified)){ 3717 selfModified |= FL_STORE_ID_DATA_MASK; 3718 } 3719 } 3720 left.isNew((Boolean)methods.get(IS_NEW).invoke(right)); 3721 left.setModified(selfModified); 3722 }catch(RuntimeException e){ 3723 throw e; 3724 }catch(Exception e){ 3725 throw new RuntimeException(e); 3726 } 3727 } 3728 3729 @Override 3730 protected void doToRight(StoreBean left, R_STORE right) { 3731 try{ 3732 Method setterMethod; 3733 int[] initialized = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 3734 int[] modified = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 3735 Arrays.fill(initialized, 0); 3736 Arrays.fill(modified, 0); 3737 if(null != (setterMethod = methods.get(Column.md5.setter)) && left.checkMd5Initialized()){ 3738 try{ 3739 setterMethod.invoke(right,cast(setterParams.get(Column.md5.setter),left.getMd5())); 3740 bitOR(Column.md5.name(),initialized); 3741 if(left.checkMd5Modified()){ 3742 bitOR(Column.md5.name(),modified); 3743 } 3744 }catch(NullCastPrimitiveException e){} 3745 } 3746 if(null != (setterMethod = methods.get(Column.encoding.setter)) && left.checkEncodingInitialized()){ 3747 try{ 3748 setterMethod.invoke(right,cast(setterParams.get(Column.encoding.setter),left.getEncoding())); 3749 bitOR(Column.encoding.name(),initialized); 3750 if(left.checkEncodingModified()){ 3751 bitOR(Column.encoding.name(),modified); 3752 } 3753 }catch(NullCastPrimitiveException e){} 3754 } 3755 if(null != (setterMethod = methods.get(Column.data.setter)) && left.checkDataInitialized()){ 3756 try{ 3757 setterMethod.invoke(right,cast(setterParams.get(Column.data.setter),left.getData())); 3758 bitOR(Column.data.name(),initialized); 3759 if(left.checkDataModified()){ 3760 bitOR(Column.data.name(),modified); 3761 } 3762 }catch(NullCastPrimitiveException e){} 3763 } 3764 if(null != (setterMethod = methods.get(SET_MODIFIED))){ 3765 if( initialized.length > 1){ 3766 setterMethod.invoke(right,cast(setterParams.get(SET_MODIFIED),initialized)); 3767 }else{ 3768 setterMethod.invoke(right,initialized[0]); 3769 } 3770 } 3771 methods.get(SET_NEW).invoke(right,left.isNew()); 3772 if( initialized.length > 1){ 3773 methods.get(SET_INITIALIZED).invoke(right,cast(setterParams.get(SET_INITIALIZED),initialized)); 3774 methods.get(SET_MODIFIED).invoke(right,cast(setterParams.get(SET_MODIFIED),modified)); 3775 }else{ 3776 methods.get(SET_INITIALIZED).invoke(right,initialized[0]); 3777 methods.get(SET_MODIFIED).invoke(right,modified[0]); 3778 } 3779 }catch(RuntimeException e){ 3780 throw e; 3781 }catch(Exception e){ 3782 throw new RuntimeException(e); 3783 } 3784 } 3785 }; 3786 /** 3787 * implementation of {@link IBeanConverter} by reflect<br> 3788 * generic type converter between {@link LogLightBean} and R_LOGLIGHT <br> 3789 * @author guyadong 3790 * @param <R_LOGLIGHT> right type 3791 * 3792 */ 3793 public static class LogLightBeanConverter<R_LOGLIGHT> extends IBeanConverter.AbstractHandle<LogLightBean,R_LOGLIGHT>{ 3794 static enum Column{ 3795 /** column method info */ 3796 id("getId","setId"), 3797 personId("getPersonId","setPersonId"), 3798 name("getName","setName"), 3799 papersType("getPapersType","setPapersType"), 3800 papersNum("getPapersNum","setPapersNum"), 3801 verifyTime("getVerifyTime","setVerifyTime"), 3802 direction("getDirection","setDirection"); 3803 final String getter; 3804 final String setter; 3805 Column(String getter,String setter){ 3806 this.getter = setter; 3807 this.setter = setter; 3808 } 3809 } 3810 private final Map<String,Method> methods = new Hashtable<String,Method>(); 3811 private final Map<String,Integer> rightIndexs = new Hashtable<String,Integer>(); 3812 private final Map<String, Class<?>> setterParams = new Hashtable<String,Class<?>>(); 3813 3814 private boolean bitCheck(String name,int...bits){ 3815 Integer id = rightIndexs.get(name); 3816 return (null == id)?false:BeanConverterUtils.bitCheck(id.intValue(),bits); 3817 } 3818 private int[] bitOR(String name,int... bits){ 3819 return BeanConverterUtils.bitOR(rightIndexs.get(name),bits); 3820 } 3821 private void getGetter(String name){ 3822 try{ 3823 methods.put(name,rightType.getMethod(name)); 3824 }catch(NoSuchMethodException e){} 3825 } 3826 private void getSetter(String name, Class<?>...types) throws NoSuchMethodException{ 3827 for(Class<?>paramType:types){ 3828 try{ 3829 methods.put(name,rightType.getMethod(name,paramType)); 3830 setterParams.put(name, paramType); 3831 return; 3832 }catch(NoSuchMethodException e){ 3833 continue; 3834 } 3835 } 3836 throw new NoSuchMethodException(); 3837 } 3838 private void getSetterNoThrow(String name, Class<?>...types){ 3839 try{ 3840 getSetter(name,types); 3841 }catch(NoSuchMethodException e){} 3842 } 3843 /** 3844 * usage: <pre>new LogLightBeanConverter<Model>(javaFields){};</pre> 3845 * @param javaFields a comma splice string,including all field name of R_LOGLIGHT,<br> 3846 * if null or empty, use default string:{@link Constant#FL_LOG_LIGHT_JAVA_FIELDS} 3847 */ 3848 public LogLightBeanConverter(String javaFields){ 3849 super(); 3850 init(javaFields); 3851 } 3852 /** @see #LogLightBeanConverter(String) */ 3853 public LogLightBeanConverter(){ 3854 this(null); 3855 } 3856 /** 3857 * constructor 3858 * @param leftClass 3859 * @param rightClass 3860 * @param javaFields see also {@link #LogLightBeanConverter(String)} 3861 */ 3862 public LogLightBeanConverter (Class<LogLightBean> leftClass, Class<R_LOGLIGHT> rightClass,String javaFields){ 3863 super(leftClass,rightClass); 3864 init(javaFields); 3865 } 3866 /** @see #LogLightBeanConverter(Class,Class,String) */ 3867 public LogLightBeanConverter (Class<LogLightBean> leftClass, Class<R_LOGLIGHT> rightClass){ 3868 this(leftClass,rightClass,null); 3869 } 3870 private void init(String javaFields){ 3871 if(null == javaFields || javaFields.isEmpty()){ 3872 javaFields = FL_LOG_LIGHT_JAVA_FIELDS; 3873 } 3874 String []rightFields = javaFields.split(","); 3875 for(int i = 0 ; i < rightFields.length; ++i){ 3876 String field = rightFields[i].trim(); 3877 if(!field.matches("\\w+")){ 3878 throw new IllegalArgumentException("invalid 'javaFields':" + javaFields); 3879 } 3880 rightIndexs.put(field,i); 3881 } 3882 try{ 3883 methods.put(IS_NEW,rightType.getMethod(IS_NEW)); 3884 methods.put(GET_INITIALIZED,rightType.getMethod(GET_INITIALIZED)); 3885 getSetter(SET_NEW,boolean.class); 3886 if(rightIndexs.size() > STATE_BIT_NUM){ 3887 getSetter(SET_INITIALIZED,int[].class,List.class); 3888 }else{ 3889 getSetter(SET_INITIALIZED,int.class); 3890 } 3891 getGetter(GET_MODIFIED); 3892 if(rightIndexs.size() > STATE_BIT_NUM){ 3893 getSetter(SET_MODIFIED,int[].class,List.class); 3894 }else{ 3895 getSetter(SET_MODIFIED,int.class); 3896 } 3897 }catch(NoSuchMethodException e){ 3898 throw new RuntimeException(e); 3899 } 3900 3901 getGetter(Column.id.getter); 3902 getSetterNoThrow(Column.id.setter,Integer.class,int.class); 3903 getGetter(Column.personId.getter); 3904 getSetterNoThrow(Column.personId.setter,Integer.class,int.class); 3905 getGetter(Column.name.getter); 3906 getSetterNoThrow(Column.name.setter,String.class); 3907 getGetter(Column.papersType.getter); 3908 getSetterNoThrow(Column.papersType.setter,Integer.class,int.class); 3909 getGetter(Column.papersNum.getter); 3910 getSetterNoThrow(Column.papersNum.setter,String.class); 3911 getGetter(Column.verifyTime.getter); 3912 getSetterNoThrow(Column.verifyTime.setter,java.util.Date.class,Long.class,long.class); 3913 getGetter(Column.direction.getter); 3914 getSetterNoThrow(Column.direction.setter,Integer.class,int.class); 3915 } 3916 @Override 3917 protected void doFromRight(LogLightBean left, R_LOGLIGHT right) { 3918 try{ 3919 Method getterMethod; 3920 left.resetIsModified(); 3921 int selfModified = 0; 3922 int[] initialized; 3923 int[] modified; 3924 if(rightIndexs.size() > STATE_BIT_NUM){ 3925 initialized = (int[])methods.get(GET_INITIALIZED).invoke(right); 3926 modified = (int[])methods.get(GET_MODIFIED).invoke(right); 3927 }else{ 3928 initialized = new int[]{(Integer)methods.get(GET_INITIALIZED).invoke(right)}; 3929 modified = new int[]{(Integer)methods.get(GET_MODIFIED).invoke(right)}; 3930 } 3931 if( bitCheck(Column.id.name(),initialized) && (null != (getterMethod = methods.get(Column.id.getter)))){ 3932 left.setId(cast(Integer.class,getterMethod.invoke(right))); 3933 if(bitCheck(Column.id.name(),modified)){ 3934 selfModified |= FL_LOG_LIGHT_ID_ID_MASK; 3935 } 3936 } 3937 if( bitCheck(Column.personId.name(),initialized) && (null != (getterMethod = methods.get(Column.personId.getter)))){ 3938 left.setPersonId(cast(Integer.class,getterMethod.invoke(right))); 3939 if(bitCheck(Column.personId.name(),modified)){ 3940 selfModified |= FL_LOG_LIGHT_ID_PERSON_ID_MASK; 3941 } 3942 } 3943 if( bitCheck(Column.name.name(),initialized) && (null != (getterMethod = methods.get(Column.name.getter)))){ 3944 left.setName(cast(String.class,getterMethod.invoke(right))); 3945 if(bitCheck(Column.name.name(),modified)){ 3946 selfModified |= FL_LOG_LIGHT_ID_NAME_MASK; 3947 } 3948 } 3949 if( bitCheck(Column.papersType.name(),initialized) && (null != (getterMethod = methods.get(Column.papersType.getter)))){ 3950 left.setPapersType(cast(Integer.class,getterMethod.invoke(right))); 3951 if(bitCheck(Column.papersType.name(),modified)){ 3952 selfModified |= FL_LOG_LIGHT_ID_PAPERS_TYPE_MASK; 3953 } 3954 } 3955 if( bitCheck(Column.papersNum.name(),initialized) && (null != (getterMethod = methods.get(Column.papersNum.getter)))){ 3956 left.setPapersNum(cast(String.class,getterMethod.invoke(right))); 3957 if(bitCheck(Column.papersNum.name(),modified)){ 3958 selfModified |= FL_LOG_LIGHT_ID_PAPERS_NUM_MASK; 3959 } 3960 } 3961 if( bitCheck(Column.verifyTime.name(),initialized) && (null != (getterMethod = methods.get(Column.verifyTime.getter)))){ 3962 left.setVerifyTime(cast(java.util.Date.class,getterMethod.invoke(right))); 3963 if(bitCheck(Column.verifyTime.name(),modified)){ 3964 selfModified |= FL_LOG_LIGHT_ID_VERIFY_TIME_MASK; 3965 } 3966 } 3967 if( bitCheck(Column.direction.name(),initialized) && (null != (getterMethod = methods.get(Column.direction.getter)))){ 3968 left.setDirection(cast(Integer.class,getterMethod.invoke(right))); 3969 if(bitCheck(Column.direction.name(),modified)){ 3970 selfModified |= FL_LOG_LIGHT_ID_DIRECTION_MASK; 3971 } 3972 } 3973 left.isNew((Boolean)methods.get(IS_NEW).invoke(right)); 3974 left.setModified(selfModified); 3975 }catch(RuntimeException e){ 3976 throw e; 3977 }catch(Exception e){ 3978 throw new RuntimeException(e); 3979 } 3980 } 3981 3982 @Override 3983 protected void doToRight(LogLightBean left, R_LOGLIGHT right) { 3984 try{ 3985 Method setterMethod; 3986 int[] initialized = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 3987 int[] modified = new int[(rightIndexs.size() + STATE_BIT_NUM - 1)>>STATE_BIT_SHIFT]; 3988 Arrays.fill(initialized, 0); 3989 Arrays.fill(modified, 0); 3990 if(null != (setterMethod = methods.get(Column.id.setter)) && left.checkIdInitialized()){ 3991 try{ 3992 setterMethod.invoke(right,cast(setterParams.get(Column.id.setter),left.getId())); 3993 bitOR(Column.id.name(),initialized); 3994 if(left.checkIdModified()){ 3995 bitOR(Column.id.name(),modified); 3996 } 3997 }catch(NullCastPrimitiveException e){} 3998 } 3999 if(null != (setterMethod = methods.get(Column.personId.setter)) && left.checkPersonIdInitialized()){ 4000 try{ 4001 setterMethod.invoke(right,cast(setterParams.get(Column.personId.setter),left.getPersonId())); 4002 bitOR(Column.personId.name(),initialized); 4003 if(left.checkPersonIdModified()){ 4004 bitOR(Column.personId.name(),modified); 4005 } 4006 }catch(NullCastPrimitiveException e){} 4007 } 4008 if(null != (setterMethod = methods.get(Column.name.setter)) && left.checkNameInitialized()){ 4009 try{ 4010 setterMethod.invoke(right,cast(setterParams.get(Column.name.setter),left.getName())); 4011 bitOR(Column.name.name(),initialized); 4012 if(left.checkNameModified()){ 4013 bitOR(Column.name.name(),modified); 4014 } 4015 }catch(NullCastPrimitiveException e){} 4016 } 4017 if(null != (setterMethod = methods.get(Column.papersType.setter)) && left.checkPapersTypeInitialized()){ 4018 try{ 4019 setterMethod.invoke(right,cast(setterParams.get(Column.papersType.setter),left.getPapersType())); 4020 bitOR(Column.papersType.name(),initialized); 4021 if(left.checkPapersTypeModified()){ 4022 bitOR(Column.papersType.name(),modified); 4023 } 4024 }catch(NullCastPrimitiveException e){} 4025 } 4026 if(null != (setterMethod = methods.get(Column.papersNum.setter)) && left.checkPapersNumInitialized()){ 4027 try{ 4028 setterMethod.invoke(right,cast(setterParams.get(Column.papersNum.setter),left.getPapersNum())); 4029 bitOR(Column.papersNum.name(),initialized); 4030 if(left.checkPapersNumModified()){ 4031 bitOR(Column.papersNum.name(),modified); 4032 } 4033 }catch(NullCastPrimitiveException e){} 4034 } 4035 if(null != (setterMethod = methods.get(Column.verifyTime.setter)) && left.checkVerifyTimeInitialized()){ 4036 try{ 4037 setterMethod.invoke(right,cast(setterParams.get(Column.verifyTime.setter),left.getVerifyTime())); 4038 bitOR(Column.verifyTime.name(),initialized); 4039 if(left.checkVerifyTimeModified()){ 4040 bitOR(Column.verifyTime.name(),modified); 4041 } 4042 }catch(NullCastPrimitiveException e){} 4043 } 4044 if(null != (setterMethod = methods.get(Column.direction.setter)) && left.checkDirectionInitialized()){ 4045 try{ 4046 setterMethod.invoke(right,cast(setterParams.get(Column.direction.setter),left.getDirection())); 4047 bitOR(Column.direction.name(),initialized); 4048 if(left.checkDirectionModified()){ 4049 bitOR(Column.direction.name(),modified); 4050 } 4051 }catch(NullCastPrimitiveException e){} 4052 } 4053 if(null != (setterMethod = methods.get(SET_MODIFIED))){ 4054 if( initialized.length > 1){ 4055 setterMethod.invoke(right,cast(setterParams.get(SET_MODIFIED),initialized)); 4056 }else{ 4057 setterMethod.invoke(right,initialized[0]); 4058 } 4059 } 4060 methods.get(SET_NEW).invoke(right,left.isNew()); 4061 if( initialized.length > 1){ 4062 methods.get(SET_INITIALIZED).invoke(right,cast(setterParams.get(SET_INITIALIZED),initialized)); 4063 methods.get(SET_MODIFIED).invoke(right,cast(setterParams.get(SET_MODIFIED),modified)); 4064 }else{ 4065 methods.get(SET_INITIALIZED).invoke(right,initialized[0]); 4066 methods.get(SET_MODIFIED).invoke(right,modified[0]); 4067 } 4068 }catch(RuntimeException e){ 4069 throw e; 4070 }catch(Exception e){ 4071 throw new RuntimeException(e); 4072 } 4073 } 4074 }; 4075}