VerticalRecordsProcessor.java

  1. package com.gh.mygreen.xlsmapper.fieldprocessor.impl;

  3. import java.lang.annotation.Annotation;
  4. import java.lang.reflect.Array;
  5. import java.lang.reflect.InvocationTargetException;
  6. import java.lang.reflect.Method;
  7. import java.util.ArrayList;
  8. import java.util.Arrays;
  9. import java.util.Collection;
  10. import java.util.HashMap;
  11. import java.util.LinkedHashMap;
  12. import java.util.List;
  13. import java.util.Map;
  14. import java.util.Optional;
  15. import java.util.concurrent.atomic.AtomicInteger;
  16. import java.util.stream.Collectors;

  18. import org.apache.poi.ss.usermodel.BorderStyle;
  19. import org.apache.poi.ss.usermodel.Cell;
  20. import org.apache.poi.ss.usermodel.CellStyle;
  21. import org.apache.poi.ss.usermodel.DataValidation;
  22. import org.apache.poi.ss.usermodel.Name;
  23. import org.apache.poi.ss.usermodel.Sheet;
  24. import org.apache.poi.ss.usermodel.Workbook;
  25. import org.apache.poi.ss.util.AreaReference;
  26. import org.apache.poi.ss.util.CellRangeAddress;
  27. import org.apache.poi.ss.util.CellRangeAddressList;
  28. import org.apache.poi.ss.util.CellReference;

  30. import com.gh.mygreen.xlsmapper.AnnotationInvalidException;
  31. import com.gh.mygreen.xlsmapper.Configuration;
  32. import com.gh.mygreen.xlsmapper.LoadingWorkObject;
  33. import com.gh.mygreen.xlsmapper.NeedProcess;
  34. import com.gh.mygreen.xlsmapper.SavingWorkObject;
  35. import com.gh.mygreen.xlsmapper.XlsMapperException;
  36. import com.gh.mygreen.xlsmapper.annotation.ArrayDirection;
  37. import com.gh.mygreen.xlsmapper.annotation.RecordTerminal;
  38. import com.gh.mygreen.xlsmapper.annotation.XlsArrayColumns;
  39. import com.gh.mygreen.xlsmapper.annotation.XlsColumn;
  40. import com.gh.mygreen.xlsmapper.annotation.XlsIgnorable;
  41. import com.gh.mygreen.xlsmapper.annotation.XlsMapColumns;
  42. import com.gh.mygreen.xlsmapper.annotation.XlsNestedRecords;
  43. import com.gh.mygreen.xlsmapper.annotation.XlsRecordFinder;
  44. import com.gh.mygreen.xlsmapper.annotation.XlsRecordOption;
  45. import com.gh.mygreen.xlsmapper.annotation.XlsRecordOption.OverOperation;
  46. import com.gh.mygreen.xlsmapper.annotation.XlsRecordOption.RemainedOperation;
  47. import com.gh.mygreen.xlsmapper.annotation.XlsVerticalRecords;
  48. import com.gh.mygreen.xlsmapper.cellconverter.CellConverter;
  49. import com.gh.mygreen.xlsmapper.cellconverter.TypeBindException;
  50. import com.gh.mygreen.xlsmapper.fieldaccessor.FieldAccessor;
  51. import com.gh.mygreen.xlsmapper.fieldprocessor.AbstractFieldProcessor;
  52. import com.gh.mygreen.xlsmapper.fieldprocessor.CellNotFoundException;
  53. import com.gh.mygreen.xlsmapper.fieldprocessor.MergedRecord;
  54. import com.gh.mygreen.xlsmapper.fieldprocessor.NestedRecordMergedSizeException;
  55. import com.gh.mygreen.xlsmapper.fieldprocessor.ProcessCase;
  56. import com.gh.mygreen.xlsmapper.fieldprocessor.RecordFinder;
  57. import com.gh.mygreen.xlsmapper.fieldprocessor.RecordHeader;
  58. import com.gh.mygreen.xlsmapper.fieldprocessor.RecordMethodCache;
  59. import com.gh.mygreen.xlsmapper.fieldprocessor.RecordMethodFacatory;
  60. import com.gh.mygreen.xlsmapper.fieldprocessor.RecordsProcessorUtil;
  61. import com.gh.mygreen.xlsmapper.localization.MessageBuilder;
  62. import com.gh.mygreen.xlsmapper.util.CellFinder;
  63. import com.gh.mygreen.xlsmapper.util.CellPosition;
  64. import com.gh.mygreen.xlsmapper.util.FieldAccessorUtils;
  65. import com.gh.mygreen.xlsmapper.util.POIUtils;
  66. import com.gh.mygreen.xlsmapper.util.Utils;
  67. import com.gh.mygreen.xlsmapper.validation.fieldvalidation.FieldFormatter;
  68. import com.gh.mygreen.xlsmapper.xml.AnnotationReadException;
  69. import com.gh.mygreen.xlsmapper.xml.AnnotationReader;


  72. /**
  73.  * アノテーション{@link XlsVerticalRecords}を処理するクラス。
  74.  *
  75.  * @version 2.1
  76.  * @author Naoki Takezoe
  77.  * @author T.TSUCHIE
  78.  *
  79.  */
  80. public class VerticalRecordsProcessor extends AbstractFieldProcessor<XlsVerticalRecords>{

  82.     @Override
  83.     public void loadProcess(final Sheet sheet, final Object beansObj, final XlsVerticalRecords anno,
  84.             final FieldAccessor accessor, final Configuration config, final LoadingWorkObject work) throws XlsMapperException {

  86.         if(!accessor.isWritable()) {
  87.             // セルの値を書き込むメソッド／フィールドがない場合はスキップ
  88.             return;
  89.         }
  90.         
  91.         if(!Utils.isLoadCase(anno.cases())) {
  92.             return;
  93.         }

  95.         final Class<?> clazz = accessor.getType();
  96.         if(Collection.class.isAssignableFrom(clazz)) {

  98.             Class<?> recordClass = anno.recordClass();
  99.             if(recordClass == Object.class) {
  100.                 recordClass = accessor.getComponentType();
  101.             }

  103.             final List<?> value = loadRecords(sheet, beansObj, anno, accessor, recordClass, config, work);
  104.             if(value != null) {
  105.                 @SuppressWarnings({"unchecked", "rawtypes"})
  106.                 Collection<?> collection = Utils.convertListToCollection(value, (Class<Collection>)clazz, config.getBeanFactory());
  107.                 accessor.setValue(beansObj, collection);
  108.             }
  109.         } else if(clazz.isArray()) {

  111.             Class<?> recordClass = anno.recordClass();
  112.             if(recordClass == Object.class) {
  113.                 recordClass = accessor.getComponentType();
  114.             }

  116.             final List<?> value = loadRecords(sheet, beansObj, anno, accessor, recordClass, config, work);
  117.             if(value != null) {
  118.                 final Object array = Array.newInstance(recordClass, value.size());
  119.                 for(int i=0; i < value.size(); i++) {
  120.                     Array.set(array, i, value.get(i));
  121.                 }

  123.                 accessor.setValue(beansObj, array);
  124.             }

  126.         } else {
  127.             throw new AnnotationInvalidException(anno, MessageBuilder.create("anno.notSupportType")
  128.                     .var("property", accessor.getNameWithClass())
  129.                     .varWithAnno("anno", XlsVerticalRecords.class)
  130.                     .varWithClass("actualType", clazz)
  131.                     .var("expectedType", "Collection(List/Set) or Array")
  132.                     .format());
  133.         }

  135.     }

  137.    private List<?> loadRecords(final Sheet sheet, final Object beansObj, final XlsVerticalRecords anno, final FieldAccessor accessor,
  138.            final Class<?> recordClass, final Configuration config, final LoadingWorkObject work) throws XlsMapperException {

  140.         // get table starting position
  141.         final Optional<CellPosition> initPosition = getHeaderPosition(sheet, anno, accessor, config);
  142.         if(!initPosition.isPresent()) {
  143.             return null;
  144.         }

  146.         // ラベルの設定
  147.         if(Utils.isNotEmpty(anno.tableLabel())) {
  148.             final Optional<Cell> tableLabelCell = CellFinder.query(sheet, anno.tableLabel(), config).findOptional();
  149.             tableLabelCell.ifPresent(c -> {
  150.                 final String label = POIUtils.getCellContents(c, config.getCellFormatter());
  151.                 accessor.setLabel(beansObj, label);

  153.             });
  154.         }

  156.         final int initColumn = initPosition.get().getColumn();
  157.         final int initRow = initPosition.get().getRow();

  159.         int hColumn = initColumn;
  160.         int hRow = initRow;

  162.         // get header columns.
  163.         final List<RecordHeader> headers = new ArrayList<>();
  164.         int rangeCount = 1;
  165.         while(true){
  166.             try {
  167.                 Cell cell = POIUtils.getCell(sheet, hColumn, hRow);
  168.                 while(POIUtils.isEmptyCellContents(cell, config.getCellFormatter()) && rangeCount < anno.range()){
  169.                     cell = POIUtils.getCell(sheet, hColumn, hRow + rangeCount);
  170.                     rangeCount++;
  171.                 }

  173.                 String cellValue = POIUtils.getCellContents(cell, config.getCellFormatter());
  174.                 if(Utils.isEmpty(cellValue)){
  175.                     break;
  176.                 } /*else {
  177.                     for(int j=hColumn; j > initColumn; j--){
  178.                         final Cell tmpCell = POIUtils.getCell(sheet, j, hRow);
  179.                         if(!POIUtils.isEmptyCellContents(tmpCell, config.getCellFormatter())){
  180.                             cell = tmpCell;
  181.                             break;
  182.                         }
  183.                     }
  184.                 }*/

  186.                 headers.add(new RecordHeader(cellValue, cell.getRowIndex() - initRow));
  187.                 hRow = hRow + rangeCount;
  188.                 rangeCount = 1;

  190.                 // 結合しているセルの場合は、はじめのセルだけ取得して、後は結合分スキップする。
  191.                 CellRangeAddress mergedRange = POIUtils.getMergedRegion(sheet, cell.getRowIndex(), cell.getColumnIndex());
  192.                 if(mergedRange != null) {
  193.                     hRow = hRow + (mergedRange.getLastRow() - mergedRange.getFirstRow());
  194.                 }

  196.             } catch(ArrayIndexOutOfBoundsException ex){
  197.                 break;
  198.             }

  200.             if(anno.headerLimit() > 0 && headers.size() >= anno.headerLimit()){
  201.                 break;
  202.             }
  203.         }

  205.         // データ行の開始位置の調整
  206.         hColumn += anno.headerRight();
  207.         CellPosition startPosition = CellPosition.of(initRow, hColumn);

  209.         // 独自の開始位置を指定する場合
  210.         final Optional<XlsRecordFinder> finderAnno = accessor.getAnnotation(XlsRecordFinder.class);
  211.         if(finderAnno.isPresent()) {
  212.             final RecordFinder finder = config.createBean(finderAnno.get().value());
  213.             startPosition = finder.find(ProcessCase.Load, finderAnno.get().args(), sheet, startPosition, beansObj, config);

  215.         }

  217.         return loadRecords(sheet, headers, anno, startPosition, 0, accessor, recordClass, config, work);
  218.    }

  220.    private List<?> loadRecords(final Sheet sheet, final List<RecordHeader> headers,
  221.            final XlsVerticalRecords anno,
  222.            final CellPosition initPosition, final int parentMergedSize,
  223.            final FieldAccessor accessor, final Class<?> recordClass,
  224.            final Configuration config, final LoadingWorkObject work) throws XlsMapperException {

  226.         final List<Object> result = new ArrayList<>();

  228.         final int initColumn = initPosition.getColumn();
  229.         final int initRow = initPosition.getRow();

  231.         final int maxColumn = initColumn + parentMergedSize;
  232.         int hColumn = initColumn;

  234.         // Check for columns
  235.         RecordsProcessorUtil.checkColumns(sheet, recordClass, headers, work.getAnnoReader(), config);
  236.         RecordsProcessorUtil.checkMapColumns(sheet, recordClass, headers, work.getAnnoReader(), config);
  237.         RecordsProcessorUtil.checkArrayColumns(sheet, recordClass, headers, work.getAnnoReader(), config);

  239.         RecordTerminal terminal = anno.terminal();
  240.         if(terminal == null){
  241.             terminal = RecordTerminal.Empty;
  242.         }

  244.         // 各種レコードのコールバック用メソッドを抽出する
  245.         final RecordMethodCache methodCache = new RecordMethodFacatory(work.getAnnoReader(), config)
  246.                 .create(recordClass, ProcessCase.Load);

  248.         // レコードの見出しに対するカラム情報のキャッシュ
  249.         final Map<String, List<FieldAccessor>> propertiesCache = new HashMap<>();

  251.         // カラムに対するConverterのキャッシュ
  252.         final Map<String, CellConverter<?>> converterCache = new HashMap<>();

  254.         final int startHeaderIndex = getStartHeaderIndexForLoading(headers, recordClass, work.getAnnoReader(), config);

  256.         // get records
  257.         while(hColumn < POIUtils.getColumns(sheet)){

  259.             if(parentMergedSize > 0 && hColumn >= maxColumn) {
  260.                 // ネストしている処理のとき、最大の処理レコード数をチェックする。
  261.                 break;
  262.             }

  264.             boolean emptyFlag = true;
  265.             // recordは、マッピング先のオブジェクトのインスタンス。
  266.             final Object record = config.createBean(recordClass);

  268.             // パスの位置の変更
  269.             work.getErrors().pushNestedPath(accessor.getName(), result.size());

  271.             // execute PreProcess listener
  272.             methodCache.getListenerClasses().forEach(listenerClass -> {
  273.                 listenerClass.getPreLoadMethods().forEach(method -> {
  274.                     Utils.invokeNeedProcessMethod(listenerClass.getObject(), method, record, sheet, config, work.getErrors(), ProcessCase.Load);
  275.                 });
  276.             });

  278.             // execute PreProcess method
  279.             methodCache.getPreLoadMethods().forEach(method -> {
  280.                 Utils.invokeNeedProcessMethod(record, method, record, sheet, config, work.getErrors(), ProcessCase.Load);
  281.             });

  283.             final List<MergedRecord> mergedRecords = new ArrayList<>();

  285.             loadMapColumns(sheet, headers, mergedRecords, CellPosition.of(initRow, hColumn), recordClass, record, config, work);

  287.             loadArrayColumns(sheet, headers, mergedRecords, CellPosition.of(initRow, hColumn), recordClass, record, config, work);

  289.             for(int i=0; i < headers.size() && hColumn < POIUtils.getColumns(sheet); i++){
  290.                 final RecordHeader headerInfo = headers.get(i);
  291.                 int hRow = initRow + headerInfo.getInterval();
  292.                 final Cell cell = POIUtils.getCell(sheet, hColumn, hRow);

  294.                 // find end of the table
  295.                 if(!POIUtils.isEmptyCellContents(cell, config.getCellFormatter())){
  296.                     emptyFlag = false;
  297.                 }

  299.                 if(terminal==RecordTerminal.Border && i == startHeaderIndex){
  300.                     if(!POIUtils.getBorderTop(cell).equals(BorderStyle.NONE)){
  301.                         emptyFlag = false;
  302.                     } else {
  303.                         emptyFlag = true;
  304.                         break;
  305.                     }
  306.                 }

  308.                 if(!anno.terminateLabel().equals("")){
  309.                     if(Utils.matches(POIUtils.getCellContents(cell, config.getCellFormatter()), anno.terminateLabel(), config)){
  310.                         emptyFlag = true;
  311.                         break;
  312.                     }
  313.                 }

  315.                 // mapping from Excel columns to Object properties.
  316.                 final List<FieldAccessor> propeties = propertiesCache.computeIfAbsent(headerInfo.getLabel(), key -> {
  317.                     return FieldAccessorUtils.getColumnPropertiesByName(
  318.                             record.getClass(), work.getAnnoReader(), config, key)
  319.                             .stream()
  320.                             .filter(p -> p.isWritable())
  321.                             .collect(Collectors.toList());
  322.                 });

  324.                 for(FieldAccessor property : propeties) {
  325.                     Cell valueCell = cell;
  326.                     final XlsColumn column = property.getAnnotationNullable(XlsColumn.class);

  328.                     if(column.headerMerged() > 0){
  329.                         hRow = hRow + column.headerMerged();
  330.                         valueCell = POIUtils.getCell(sheet, hColumn, hRow);
  331.                     }

  333.                     // for merged cell
  334.                     if(POIUtils.isEmptyCellContents(valueCell, config.getCellFormatter())){
  335.                         CellStyle valueCellFormat = valueCell.getCellStyle();
  336.                         if(column.merged() && POIUtils.getBorderRight(valueCell).equals(BorderStyle.NONE)){
  337.                             for(int k=hColumn; k > initColumn; k--){
  338.                                 final Cell tmpCell = POIUtils.getCell(sheet, k, hRow);
  339.                                 final CellStyle tmpCellFormat = tmpCell.getCellStyle();

  341.                                 if(!POIUtils.getBorderLeft(tmpCell).equals(BorderStyle.NONE)){
  342.                                     break;
  343.                                 }

  345.                                 if(!POIUtils.isEmptyCellContents(tmpCell, config.getCellFormatter())){
  346.                                     valueCell = tmpCell;
  347.                                     break;
  348.                                 }
  349.                             }
  350.                         }
  351.                     }

  353.                     if(column.headerMerged() > 0){
  354.                         hRow = hRow - column.headerMerged();
  355.                     }

  357.                     CellRangeAddress mergedRange = POIUtils.getMergedRegion(sheet, valueCell.getRowIndex(), valueCell.getColumnIndex());
  358.                     if(mergedRange != null) {
  359.                         int mergedSize =  mergedRange.getLastColumn() - mergedRange.getFirstColumn() + 1;
  360.                         mergedRecords.add(new MergedRecord(headerInfo, mergedRange, mergedSize));
  361.                     } else {
  362.                         mergedRecords.add(new MergedRecord(headerInfo, CellRangeAddress.valueOf(POIUtils.formatCellAddress(valueCell)), 1));
  363.                     }

  365.                     if(!Utils.isLoadCase(column.cases())) {
  366.                         continue;
  367.                     }

  369.                     // set for value
  370.                     property.setPosition(record, CellPosition.of(valueCell));
  371.                     property.setLabel(record, headerInfo.getLabel());

  373.                     final Cell tempCommentCell = valueCell;
  374.                     property.getCommentSetter().ifPresent(setter -> 
  375.                             config.getCommentOperator().loadCellComment(setter, tempCommentCell, record, property, config));
  376.                     
  377.                     final CellConverter<?> converter = converterCache.computeIfAbsent(property.getName(), key -> getCellConverter(property, config));
  378.                     if(converter instanceof FieldFormatter) {
  379.                         work.getErrors().registerFieldFormatter(property.getName(), property.getType(), (FieldFormatter<?>)converter, true);
  380.                     }

  382.                     try {
  383.                         final Object value = converter.toObject(valueCell);
  384.                         property.setValue(record, value);
  385.                     } catch(TypeBindException e) {
  386.                         work.addTypeBindError(e, valueCell, property.getName(), headerInfo.getLabel());
  387.                         if(!config.isContinueTypeBindFailure()) {
  388.                             throw e;
  389.                         }
  390.                     }
  391.                 }
  392.             }

  394.             // execute nested record
  395.             final int skipSize = loadNestedRecords(sheet, headers, mergedRecords, anno, CellPosition.of(initRow, hColumn), record, config, work);
  396.             if(parentMergedSize > 0 && skipSize > 0 && (hColumn + skipSize) > maxColumn) {
  397.                 // check over merged cell.
  398.                 String message = String.format("Over merged size. In sheet '%s' with columnIndex=%d, over the columnIndex=%s.",
  399.                         sheet.getSheetName(), hColumn + skipSize, maxColumn);
  400.                 throw new NestedRecordMergedSizeException(sheet.getSheetName(), skipSize, message);
  401.             }


  404.             if(emptyFlag){
  405.                 // パスの位置の変更
  406.                 work.getErrors().popNestedPath();
  407.                 break;
  408.             }

  410.             if(isAvailabledRecord(methodCache.getIgnoreableMethod(), record)) {
  411.                 // 有効なレコードのみ、処理を行う
  412.                 result.add(record);

  414.                 // set PostProcess listener
  415.                 methodCache.getListenerClasses().forEach(listenerClass -> {
  416.                     listenerClass.getPostLoadMethods().forEach(method -> {
  417.                         work.addNeedPostProcess(new NeedProcess(record, listenerClass.getObject(), method));
  418.                     });
  419.                 });

  421.                 // set PostProcess method
  422.                 methodCache.getPostLoadMethods().forEach(method -> {
  423.                     work.addNeedPostProcess(new NeedProcess(record, record, method));
  424.                 });

  426.             }

  428.             // パスの位置の変更
  429.             work.getErrors().popNestedPath();

  431.             if(skipSize > 0) {
  432.                 hColumn += skipSize;
  433.             } else {
  434.                 hColumn++;
  435.             }

  437.         }

  439.         return result;
  440.     }

  442.     /**
  443.      * 表の開始位置（見出し）の位置情報を取得する。
  444.      *
  445.      * @param sheet
  446.      * @param anno
  447.      * @param accessor
  448.      * @param config
  449.      * @return 表の開始位置。指定したラベルが見つからない場合、設定によりnullを返す。
  450.      * @throws AnnotationInvalidException アノテーションの値が不正で、表の開始位置が位置が見つからない場合。
  451.      * @throws CellNotFoundException 指定したラベルが見つからない場合。
  452.      */
  453.     private Optional<CellPosition> getHeaderPosition(final Sheet sheet, final XlsVerticalRecords anno,
  454.             final FieldAccessor accessor, final Configuration config) throws AnnotationInvalidException, CellNotFoundException {

  456.         if(Utils.isNotEmpty(anno.headerAddress())) {
  457.             try {
  458.                 return Optional.of(CellPosition.of(anno.headerAddress()));

  460.             } catch(IllegalArgumentException e) {
  461.                 throw new AnnotationInvalidException(anno, MessageBuilder.create("anno.attr.invalidAddress")
  462.                         .var("property", accessor.getNameWithClass())
  463.                         .varWithAnno("anno", XlsVerticalRecords.class)
  464.                         .var("attrName", "headerAddress")
  465.                         .var("attrValue", anno.headerAddress())
  466.                         .format());

  468.             }

  470.         } else if(Utils.isNotEmpty(anno.tableLabel())) {
  471.             try {
  472.                 final Cell labelCell = CellFinder.query(sheet, anno.tableLabel(), config).findWhenNotFoundException();

  474.                 if(anno.tableLabelAbove()) {
  475.                     // 表の見出しが上にある場合、左側に補正する
  476.                     int initColumn = labelCell.getColumnIndex() + anno.right()-1;
  477.                     int initRow = labelCell.getRowIndex() + anno.bottom();
  478.                     return Optional.of(CellPosition.of(initRow, initColumn));

  480.                 } else {

  482.                     int initColumn = labelCell.getColumnIndex() + anno.right();
  483.                     int initRow = labelCell.getRowIndex();
  484.                     return Optional.of(CellPosition.of(initRow, initColumn));

  486.                 }

  488.             } catch(CellNotFoundException ex) {
  489.                 if(anno.optional()) {
  490.                     return Optional.empty();
  491.                 } else {
  492.                     throw ex;
  493.                 }
  494.             }
  495.         } else {
  496.             if(anno.headerRow() < 0) {
  497.                 throw  new AnnotationInvalidException(anno, MessageBuilder.create("anno.attr.min")
  498.                         .var("property", accessor.getNameWithClass())
  499.                         .varWithAnno("anno", XlsVerticalRecords.class)
  500.                         .var("attrName", "headerRow")
  501.                         .var("attrValue", anno.headerRow())
  502.                         .var("min", 0)
  503.                         .format());
  504.             }

  506.             if(anno.headerColumn() < 0) {
  507.                 throw new AnnotationInvalidException(anno, MessageBuilder.create("anno.attr.min")
  508.                         .var("property", accessor.getNameWithClass())
  509.                         .varWithAnno("anno", XlsVerticalRecords.class)
  510.                         .var("attrName", "column")
  511.                         .var("attrValue", anno.headerColumn())
  512.                         .var("min", 0)
  513.                         .format());

  515.             }
  516.             return Optional.of(CellPosition.of(anno.headerRow(), anno.headerColumn()));
  517.         }
  518.     }

  520.     /**
  521.      * 表の見出しから、レコードのJavaクラスの定義にあるカラムの定義で初めて見つかるリストのインデックスを取得する。
  522.      * <p>カラムの定義とは、アノテーション「@XlsColumn」が付与されたもの。
  523.      * @param headers 表の見出し情報。
  524.      * @param recordClass アノテーション「@XlsColumn」が定義されたフィールドを持つレコード用のクラス。
  525.      * @param annoReader {@link AnnotationReader}
  526.      * @param config システム設定
  527.      * @return 引数「headers」の該当する要素のインデックス番号。不明な場合は0を返す。
  528.      */
  529.     private int getStartHeaderIndexForLoading(final List<RecordHeader> headers, Class<?> recordClass,
  530.             final AnnotationReader annoReader,  final Configuration config) {

  532.         // レコードクラスが不明の場合、0を返す。
  533.         if((recordClass == null || recordClass.equals(Object.class))) {
  534.             return 0;
  535.         }

  537.         for(int i=0; i < headers.size(); i++) {
  538.             RecordHeader headerInfo = headers.get(i);
  539.             final List<FieldAccessor> propeties = FieldAccessorUtils.getColumnPropertiesByName(
  540.                     recordClass, annoReader, config, headerInfo.getLabel())
  541.                     .stream()
  542.                     .filter(p -> p.isWritable())
  543.                     .collect(Collectors.toList());
  544.             if(!propeties.isEmpty()) {
  545.                 return i;
  546.             }
  547.         }

  549.         return 0;

  551.     }

  553.     private void loadMapColumns(final Sheet sheet, final List<RecordHeader> headers, final List<MergedRecord> mergedRecords,
  554.             final CellPosition beginPosition, final Class<?> recordClass, final Object record, final Configuration config, final LoadingWorkObject work) throws XlsMapperException {

  556.         final List<FieldAccessor> properties = FieldAccessorUtils.getPropertiesWithAnnotation(
  557.                 recordClass, work.getAnnoReader(), XlsMapColumns.class)
  558.                 .stream()
  559.                 .filter(p -> p.isWritable())
  560.                 .collect(Collectors.toList());

  562.         for(FieldAccessor property : properties) {
  563.             final XlsMapColumns mapAnno = property.getAnnotationNullable(XlsMapColumns.class);

  565.             if(!Utils.isLoadCase(mapAnno.cases())) {
  566.                 continue;
  567.             }

  569.             Class<?> valueClass = mapAnno.valueClass();
  570.             if(valueClass == Object.class) {
  571.                 valueClass = property.getComponentType();
  572.             }

  574.             // get converter (map key class)
  575.             final CellConverter<?> converter = getCellConverter(valueClass, property, config);
  576.             if(converter instanceof FieldFormatter) {
  577.                 work.getErrors().registerFieldFormatter(property.getName(), valueClass, (FieldFormatter<?>)converter, true);
  578.             }

  580.             boolean foundPreviousColumn = false;
  581.             final Map<String, Object> map = new LinkedHashMap<>();
  582.             for(RecordHeader headerInfo : headers){
  583.                 int hRow = beginPosition.getRow() + headerInfo.getInterval();
  584.                 if(Utils.matches(headerInfo.getLabel(), mapAnno.previousColumnName(), config)){
  585.                     foundPreviousColumn = true;
  586.                     hRow++;
  587.                     continue;
  588.                 }

  590.                 if(Utils.isNotEmpty(mapAnno.nextColumnName()) && Utils.matches(headerInfo.getLabel(), mapAnno.nextColumnName(), config)) {
  591.                     break;
  592.                 }

  594.                 if(foundPreviousColumn){
  595.                     final Cell cell = POIUtils.getCell(sheet, beginPosition.getColumn(), hRow);
  596.                     property.setMapPosition(record, CellPosition.of(cell), headerInfo.getLabel());
  597.                     property.setMapLabel(record, headerInfo.getLabel(), headerInfo.getLabel());

  599.                     property.getMapCommentSetter().ifPresent(setter -> 
  600.                     config.getCommentOperator().loadMapCellComment(setter, cell, record, headerInfo.getLabel(), property, config));
  601.                     
  602.                     CellRangeAddress mergedRange = POIUtils.getMergedRegion(sheet, cell.getRowIndex(), cell.getColumnIndex());
  603.                     if(mergedRange != null) {
  604.                         int mergedSize =  mergedRange.getLastColumn() - mergedRange.getFirstColumn() + 1;
  605.                         mergedRecords.add(new MergedRecord(headerInfo, mergedRange, mergedSize));
  606.                     } else {
  607.                         mergedRecords.add(new MergedRecord(headerInfo, CellRangeAddress.valueOf(POIUtils.formatCellAddress(cell)), 1));
  608.                     }

  610.                     try {
  611.                         final Object value = converter.toObject(cell);
  612.                         map.put(headerInfo.getLabel(), value);
  613.                     } catch(TypeBindException e) {
  614.                         e.setBindClass(valueClass);  // マップの項目のタイプに変更
  615.                         work.addTypeBindError(e, cell, String.format("%s[%s]", property.getName(), headerInfo.getLabel()), headerInfo.getLabel());
  616.                         if(!config.isContinueTypeBindFailure()) {
  617.                             throw e;
  618.                         }
  619.                     }
  620.                 }
  621.             }

  623.             if(foundPreviousColumn) {
  624.                 property.setValue(record, map);
  625.             }
  626.         }
  627.     }

  629.     private void loadArrayColumns(final Sheet sheet, final List<RecordHeader> headers, final List<MergedRecord> mergedRecords,
  630.             final CellPosition beginPosition, final Class<?> recordClass, final Object record, final Configuration config, final LoadingWorkObject work) throws XlsMapperException {

  632.         for(RecordHeader headerInfo : headers) {
  633.             int hRow = beginPosition.getRow() + headerInfo.getInterval();

  635.             // アノテーション「@XlsArrayColumns」の属性「columnName」と一致するプロパティを取得する。
  636.             final List<FieldAccessor> arrayProperties = FieldAccessorUtils.getArrayColumnsPropertiesByName(
  637.                     recordClass, work.getAnnoReader(), config, headerInfo.getLabel())
  638.                     .stream()
  639.                     .filter(f -> f.isWritable())
  640.                     .collect(Collectors.toList());

  642.             if(arrayProperties.isEmpty()) {
  643.                 continue;
  644.             }

  646.             for(FieldAccessor property : arrayProperties) {

  648.                 final XlsArrayColumns arrayAnno = property.getAnnotationNullable(XlsArrayColumns.class);

  650.                 if(!Utils.isLoadCase(arrayAnno.cases())) {
  651.                     continue;
  652.                 }
  653.                 Class<?> elementClass = arrayAnno.elementClass();
  654.                 if(elementClass == Object.class) {
  655.                     elementClass = property.getComponentType();
  656.                 }

  658.                 // get converter (component class)
  659.                 final CellConverter<?> converter = getCellConverter(elementClass, property, config);
  660.                 if(converter instanceof FieldFormatter) {
  661.                     work.getErrors().registerFieldFormatter(property.getName(), elementClass, (FieldFormatter<?>)converter, true);
  662.                 }

  664.                 final CellPosition initPosition = CellPosition.of(hRow, beginPosition.getColumn());

  666.                 ArrayCellsHandler arrayHandler = new ArrayCellsHandler(property, record, elementClass, sheet, config);
  667.                 arrayHandler.setLabel(headerInfo.getLabel());

  669.                 final List<Object> result = arrayHandler.handleOnLoading(arrayAnno, initPosition, converter, work, ArrayDirection.Vertical);

  671.                 if(result != null) {
  672.                     // インデックスが付いていないラベルの設定
  673.                     property.setLabel(record, headerInfo.getLabel());
  674.                 }

  676.                 final Class<?> propertyType = property.getType();
  677.                 if(Collection.class.isAssignableFrom(propertyType)) {
  678.                     if(result != null) {
  679.                         @SuppressWarnings({"unchecked", "rawtypes"})
  680.                         Collection<?> collection = Utils.convertListToCollection(result, (Class<Collection>)propertyType, config.getBeanFactory());
  681.                         property.setValue(record, collection);
  682.                     }

  684.                 } else if(propertyType.isArray()) {

  686.                     if(result != null) {
  687.                         final Object array = Array.newInstance(elementClass, result.size());
  688.                         for(int i=0; i < result.size(); i++) {
  689.                             Array.set(array, i, result.get(i));
  690.                         }
  691.                         property.setValue(record, array);
  692.                     }

  694.                 } else {
  695.                     throw new AnnotationInvalidException(arrayAnno, MessageBuilder.create("anno.notSupportType")
  696.                             .var("property", property.getNameWithClass())
  697.                             .varWithAnno("anno", XlsArrayColumns.class)
  698.                             .varWithClass("actualType", propertyType)
  699.                             .var("expectedType", "Collection(List/Set) or Array")
  700.                             .format());
  701.                 }
  702.             }
  703.         }

  705.     }

  707.     @SuppressWarnings("unchecked")
  708.     private int loadNestedRecords(final Sheet sheet, final List<RecordHeader> headers, final List<MergedRecord> mergedRecords,
  709.             final XlsVerticalRecords anno,
  710.             final CellPosition beginPosition,
  711.             final Object record,
  712.             final Configuration config, final LoadingWorkObject work) throws XlsMapperException {

  714.         // 読み飛ばす、レコード数。
  715.         // 基本的に結合している個数による。
  716.         int skipSize = 0;

  718.         final List<FieldAccessor> nestedProperties = FieldAccessorUtils.getPropertiesWithAnnotation(
  719.                 record.getClass(), work.getAnnoReader(), XlsNestedRecords.class)
  720.                 .stream()
  721.                 .filter(p -> p.isWritable())
  722.                 .collect(Collectors.toList());
  723.         
  724.         for(FieldAccessor property : nestedProperties) {

  726.             final XlsNestedRecords nestedAnno = property.getAnnotationNullable(XlsNestedRecords.class);

  728.             if(!Utils.isLoadCase(nestedAnno.cases())) {
  729.                 continue;
  730.             }

  732.             final Class<?> clazz = property.getType();
  733.             if(Collection.class.isAssignableFrom(clazz)) {
  734.                 // mapping by one-to-many

  736.                 int mergedSize = RecordsProcessorUtil.checkNestedMergedSizeRecords(sheet, mergedRecords);
  737.                 if(skipSize < mergedSize) {
  738.                     skipSize = mergedSize;
  739.                 }

  741.                 Class<?> recordClass = nestedAnno.recordClass();
  742.                 if(recordClass == Object.class) {
  743.                     recordClass = property.getComponentType();
  744.                 }

  746.                 List<?> value = loadRecords(sheet, headers, anno, beginPosition, mergedSize, property, recordClass, config, work);
  747.                 if(value != null) {
  748.                     Collection<?> collection = Utils.convertListToCollection(value, (Class<Collection>)clazz, config.getBeanFactory());
  749.                     property.setValue(record, collection);
  750.                 }

  752.             } else if(clazz.isArray()) {
  753.                 // mapping by one-to-many

  755.                 int mergedSize = RecordsProcessorUtil.checkNestedMergedSizeRecords(sheet, mergedRecords);
  756.                 if(skipSize < mergedSize) {
  757.                     skipSize = mergedSize;
  758.                 }

  760.                 Class<?> recordClass = anno.recordClass();
  761.                 if(recordClass == Object.class) {
  762.                     recordClass = property.getComponentType();
  763.                 }

  765.                 List<?> value = loadRecords(sheet, headers, anno, beginPosition, mergedSize, property, recordClass, config, work);
  766.                 if(value != null) {
  767.                     final Object array = Array.newInstance(recordClass, value.size());
  768.                     for(int i=0; i < value.size(); i++) {
  769.                         Array.set(array, i, value.get(i));
  770.                     }

  772.                     property.setValue(record, array);
  773.                 }

  775.             } else {
  776.                 // mapping by one-to-tone

  778.                 int mergedSize = 1;
  779.                 if(skipSize < mergedSize) {
  780.                     skipSize = mergedSize;
  781.                 }

  783.                 Class<?> recordClass = anno.recordClass();
  784.                 if(recordClass == Object.class) {
  785.                     recordClass = property.getType();
  786.                 }

  788.                 List<?> value = loadRecords(sheet, headers, anno, beginPosition, mergedSize, property, recordClass, config, work);
  789.                 if(value != null && !value.isEmpty()) {
  790.                     property.setValue(record, value.get(0));
  791.                 }

  793.             }
  794.         }

  796.         return skipSize;
  797.     }

  799.     /**
  800.      * レコードが有効かどうか判定する
  801.      * <p>アノテーション{@link XlsIgnorable}のメソッドで判定を行う。
  802.      * @param ignoreMethod レコードの判定を無視するかどうかの判定に使用するメソッド
  803.      * @param record 判定対象のレコードのインスタンス。
  804.      * @return trueの場合は有効。
  805.      */
  806.     private boolean isAvailabledRecord(final Optional<Method> ignoreMethod, final Object record)
  807.             throws AnnotationReadException, AnnotationInvalidException {

  809.         if(!ignoreMethod.isPresent()) {
  810.             // 判定用のメソッドが存在しない場合
  811.             return true;
  812.         }

  814.         try {
  815.             boolean ignored = (boolean)ignoreMethod.get().invoke(record);
  816.             return !ignored;

  818.         } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  819.             throw new RuntimeException("fail execute method of ignoreable record", e);
  820.         }

  822.     }

  824.     @Override
  825.     public void saveProcess(final Sheet sheet, final Object beansObj, final XlsVerticalRecords anno,
  826.             final FieldAccessor accessor, final Configuration config, final SavingWorkObject work) throws XlsMapperException {

  828.         if(!accessor.isReadable()) {
  829.             // セルの値を参照するメソッド／フィールドがない場合はスキップ
  830.             return;
  831.         }
  832.         
  833.         if(!Utils.isSaveCase(anno.cases())) {
  834.             return;
  835.         }

  837.         final Class<?> clazz = accessor.getType();
  838.         final Object result = accessor.getValue(beansObj);
  839.         if(Collection.class.isAssignableFrom(clazz)) {

  841.             Class<?> recordClass = anno.recordClass();
  842.             if(recordClass == Object.class) {
  843.                 recordClass = accessor.getComponentType();
  844.             }

  846.             final Collection<Object> value = (result == null ? new ArrayList<Object>() : (Collection<Object>) result);
  847.             final List<Object> list = Utils.convertCollectionToList(value);
  848.             saveRecords(sheet, beansObj, anno, accessor, recordClass, list, config, work);

  850.         } else if(clazz.isArray()) {

  852.             Class<?> recordClass = anno.recordClass();
  853.             if(recordClass == Object.class) {
  854.                 recordClass = accessor.getComponentType();
  855.             }

  857.             final List<Object> list = Utils.asList(result, recordClass);
  858.             saveRecords(sheet, beansObj, anno, accessor, recordClass, list, config, work);

  860.         } else {
  861.             throw new AnnotationInvalidException(anno, MessageBuilder.create("anno.notSupportType")
  862.                     .var("property", accessor.getNameWithClass())
  863.                     .varWithAnno("anno", XlsVerticalRecords.class)
  864.                     .varWithClass("actualType", clazz)
  865.                     .var("expectedType", "Collection(List/Set) or Array")
  866.                     .format());
  867.         }

  869.     }

  871.     private void saveRecords(final Sheet sheet, final Object beansObj, final XlsVerticalRecords anno, final FieldAccessor accessor,
  872.             final Class<?> recordClass, final List<Object> result,
  873.             final Configuration config, final SavingWorkObject work) throws XlsMapperException {

  875.         RecordsProcessorUtil.checkSavingNestedRecordClass(recordClass, accessor, work.getAnnoReader());

  877.         // get table starting position
  878.         final Optional<CellPosition> initPosition = getHeaderPosition(sheet, anno, accessor, config);
  879.         if(!initPosition.isPresent()) {
  880.             return;
  881.         }

  883.         // ラベルの設定
  884.         if(Utils.isNotEmpty(anno.tableLabel())) {
  885.             final Optional<Cell> tableLabelCell = CellFinder.query(sheet, anno.tableLabel(), config).findOptional();
  886.             tableLabelCell.ifPresent(c -> {
  887.                 final String label = POIUtils.getCellContents(c, config.getCellFormatter());
  888.                 accessor.setLabel(beansObj, label);

  890.             });
  891.         }

  893.         final int initColumn = initPosition.get().getColumn();
  894.         final int initRow = initPosition.get().getRow();

  896.         int hColumn = initColumn;
  897.         int hRow = initRow;

  899.         // get header columns.
  900.         final List<RecordHeader> headers = new ArrayList<>();
  901.         int rangeCount = 1;
  902.         while(true) {
  903.             try {
  904.                 Cell cell = POIUtils.getCell(sheet, hColumn, hRow);
  905.                 while(POIUtils.isEmptyCellContents(cell, config.getCellFormatter()) && rangeCount < anno.range()) {
  906.                     cell = POIUtils.getCell(sheet, hColumn, hRow + rangeCount);
  907.                     rangeCount++;
  908.                 }

  910.                 final String cellValue = POIUtils.getCellContents(cell, config.getCellFormatter());
  911.                 if(Utils.isEmpty(cellValue)) {
  912.                     break;
  913.                 }

  915.                 headers.add(new RecordHeader(cellValue, cell.getRowIndex() - initRow));
  916.                 hRow = hRow + rangeCount;
  917.                 rangeCount = 1;

  919.                 // 結合しているセルの場合は、はじめのセルだけ取得して、後は結合分スキップする。
  920.                 CellRangeAddress mergedRange = POIUtils.getMergedRegion(sheet, cell.getRowIndex(), cell.getColumnIndex());
  921.                 if(mergedRange != null) {
  922.                     hRow = hRow + (mergedRange.getLastRow() - mergedRange.getFirstRow());
  923.                 }

  925.             } catch(ArrayIndexOutOfBoundsException ex) {
  926.                 break;
  927.             }

  929.             if(anno.headerLimit() > 0 && headers.size() >= anno.headerLimit()){
  930.                 break;
  931.             }
  932.         }

  934.         // レコードの操作のアノテーション
  935.         final XlsRecordOption recordOptionAnno = getRecordOptionAnnotation(accessor);

  937.         // データ行の開始位置の調整
  938.         hColumn += anno.headerRight();
  939.         CellPosition startPosition = CellPosition.of(initRow, hColumn);

  941.         // 独自の開始位置を指定する場合
  942.         final Optional<XlsRecordFinder> finderAnno = accessor.getAnnotation(XlsRecordFinder.class);
  943.         if(finderAnno.isPresent()) {
  944.             final RecordFinder finder = config.createBean(finderAnno.get().value());
  945.             startPosition = finder.find(ProcessCase.Save, finderAnno.get().args(), sheet, startPosition, beansObj, config);

  947.         }

  949.         // 書き込んだセルの範囲などの情報
  950.         final RecordOperation recordOperation = new RecordOperation(recordOptionAnno);
  951.         recordOperation.setupCellPositoin(startPosition);

  953.         // XlsColumn(merged=true)の結合したセルの情報
  954.         final List<CellRangeAddress> mergedRanges = new ArrayList<CellRangeAddress>();

  956.         saveRecords(sheet, headers,
  957.                 anno,
  958.                 startPosition, new AtomicInteger(0),
  959.                 accessor, recordClass, result,
  960.                 config, work,
  961.                 mergedRanges, recordOperation);

  963.         // 書き込むデータがない場合は、1行目の終端を操作範囲とする。
  964.         if(result.isEmpty()) {
  965.             recordOperation.setupCellPositoin(hRow-1, startPosition.getColumn());
  966.         }

  968.         if(config.isCorrectCellDataValidationOnSave()) {
  969.             correctDataValidation(sheet, recordOperation);
  970.         }

  972.         if(config.isCorrectNameRangeOnSave()) {
  973.             correctNameRange(sheet, recordOperation);
  974.         }
  975.     }

  977.     /**
  978.      * アノテーション{@link XlsRecordOption}を取得する。
  979.      * ただし、付与されていない場合は、属性にデフォルト値が指定されているものを取得する。
  980.      * @param accessor フィールド情報
  981.      * @return アノテーションのインスタンス
  982.      */
  983.     private XlsRecordOption getRecordOptionAnnotation(final FieldAccessor accessor) {

  985.         return accessor.getAnnotation(XlsRecordOption.class)
  986.                 .orElseGet(() -> new XlsRecordOption() {

  988.                     @Override
  989.                     public Class<? extends Annotation> annotationType() {
  990.                         return XlsRecordOption.class;
  991.                     }

  993.                     @Override
  994.                     public RemainedOperation remainedOperation() {
  995.                         return RemainedOperation.None;
  996.                     }

  998.                     @Override
  999.                     public OverOperation overOperation() {
  1000.                         return OverOperation.Break;
  1001.                     }
  1002.                 });


  1005.     }

  1007.     private void saveRecords(final Sheet sheet, final List<RecordHeader> headers,
  1008.             final XlsVerticalRecords anno,
  1009.             final CellPosition initPosition, final AtomicInteger nestedRecordSize,
  1010.             final FieldAccessor accessor, final Class<?> recordClass, final List<Object> result,
  1011.             final Configuration config, final SavingWorkObject work,
  1012.             final List<CellRangeAddress> mergedRanges, final RecordOperation recordOperation) throws XlsMapperException {

  1014.         final int initColumn = initPosition.getColumn();
  1015.         final int initRow = initPosition.getRow();

  1017.         int hColumn = initColumn;

  1019.         // Check for columns
  1020.         RecordsProcessorUtil.checkColumns(sheet, recordClass, headers, work.getAnnoReader(), config);
  1021.         RecordsProcessorUtil.checkMapColumns(sheet, recordClass, headers, work.getAnnoReader(), config);
  1022.         RecordsProcessorUtil.checkArrayColumns(sheet, recordClass, headers, work.getAnnoReader(), config);

  1024.         /*
  1025.          * 書き込む時には終了位置の判定は、Borderで固定する必要がある。
  1026.          * ・Emptyの場合だと、テンプレート用のシートなので必ずデータ用のセルが、空なので書き込まれなくなる。
  1027.          * ・Emptyの場合、Borderに補正して書き込む。
  1028.          */
  1029.         RecordTerminal terminal = anno.terminal();
  1030.         if(terminal == RecordTerminal.Empty) {
  1031.             terminal = RecordTerminal.Border;
  1032.         } else if(terminal == null){
  1033.             terminal = RecordTerminal.Border;
  1034.         }

  1036.         // 各種レコードのコールバック用メソッドを抽出する
  1037.         final RecordMethodCache methodCache = new RecordMethodFacatory(work.getAnnoReader(), config)
  1038.                 .create(recordClass, ProcessCase.Save);

  1040.         // レコードの見出しに対するカラム情報のキャッシュ
  1041.         final Map<String, List<FieldAccessor>> propertiesCache = new HashMap<>();

  1043.         // カラムに対するConverterのキャッシュ
  1044.         final Map<String, CellConverter<?>> converterCache = new HashMap<>();

  1046.         final int startHeaderIndex = getStartHeaderIndexForSaving(headers, recordClass, work.getAnnoReader(), config);

  1048.         // get records
  1049.         for(int r=0; r < POIUtils.getColumns(sheet); r++) {

  1051.             boolean emptyFlag = true;

  1053.             // 書き込むレコードのオブジェクトを取得。データが0件の場合、nullとなる。
  1054.             final Object record;
  1055.             if(r < result.size()) {
  1056.                 record = result.get(r);
  1057.             } else {
  1058.                 record = null;
  1059.             }

  1061.             // パスの位置の変更
  1062.             work.getErrors().pushNestedPath(accessor.getName(), r);

  1064.             if(record != null) {

  1066.                 // execute PreProcess listner
  1067.                 methodCache.getListenerClasses().forEach(listenerClass -> {
  1068.                     listenerClass.getPreSaveMethods().forEach(method -> {
  1069.                         Utils.invokeNeedProcessMethod(listenerClass.getObject(), method, record, sheet, config, work.getErrors(), ProcessCase.Save);
  1070.                     });
  1071.                 });

  1073.                 // execute PreProcess method
  1074.                 methodCache.getPreSaveMethods().forEach(method -> {
  1075.                     Utils.invokeNeedProcessMethod(record, method, record, sheet, config, work.getErrors(), ProcessCase.Save);
  1076.                 });

  1078.             }

  1080. //            // レコードの各列処理で既に行を追加したかどうかのフラグ。
  1081. //            boolean insertRows = false;

  1083. //            // レコードの各列処理で既に行を削除したかどうかのフラグ。
  1084. //            boolean deleteRows = false;


  1087.             // 書き込んだセルの座標
  1088.             // ネストしたときに、結合するための情報として使用する。
  1089.             List<CellPosition> valueCellPositions = new ArrayList<>();

  1091.             // hRowという上限がない
  1092.             for(int i=0; i < headers.size(); i++) {
  1093.                 final RecordHeader headerInfo = headers.get(i);
  1094.                 int hRow = initRow + headerInfo.getInterval();
  1095.                 final Cell cell = POIUtils.getCell(sheet, hColumn, hRow);

  1097.                 // find end of the table
  1098.                 if(!POIUtils.getCellContents(cell, config.getCellFormatter()).equals("")){
  1099.                     emptyFlag = false;
  1100.                 }

  1102.                 if(terminal == RecordTerminal.Border && i == startHeaderIndex){
  1103.                     final CellStyle format = cell.getCellStyle();
  1104.                     if(!POIUtils.getBorderTop(cell).equals(BorderStyle.NONE)){
  1105.                         emptyFlag = false;
  1106.                     } else {
  1107.                         emptyFlag = true;
  1108. //                            break;
  1109.                     }
  1110.                 }

  1112.                 if(!anno.terminateLabel().equals("")){
  1113.                     if(Utils.matches(POIUtils.getCellContents(cell, config.getCellFormatter()), anno.terminateLabel(), config)){
  1114.                         emptyFlag = true;
  1115. //                            break;
  1116.                     }
  1117.                 }

  1119.                 // mapping from Excel columns to Object properties.
  1120.                 if(record != null) {
  1121.                     final List<FieldAccessor> propeties = propertiesCache.computeIfAbsent(headerInfo.getLabel(), key -> {
  1122.                         return FieldAccessorUtils.getColumnPropertiesByName(
  1123.                                 record.getClass(), work.getAnnoReader(), config, key)
  1124.                                 .stream()
  1125.                                 .filter(p -> p.isReadable())
  1126.                                 .collect(Collectors.toList());
  1127.                     });

  1129.                     for(FieldAccessor property : propeties) {
  1130.                         Cell valueCell = cell;
  1131.                         final XlsColumn column = property.getAnnotationNullable(XlsColumn.class);

  1133.                         //TODO: マージを考慮する必要はないかも
  1134.                         if(column.headerMerged() > 0) {
  1135.                             hRow = hRow + column.headerMerged();
  1136.                             valueCell = POIUtils.getCell(sheet, hColumn, hRow);
  1137.                         }

  1139.                         // for merged cell
  1140.                         if(POIUtils.isEmptyCellContents(valueCell, config.getCellFormatter())) {
  1141.                             if(column.merged() && POIUtils.getBorderRight(valueCell).equals(BorderStyle.NONE)){
  1142.                                 for(int k=hColumn-1; k > hColumn; k--){
  1143.                                     Cell tmpCell = POIUtils.getCell(sheet, k, hRow);
  1144.                                     final CellStyle tmpCellFormat = tmpCell.getCellStyle();
  1145.                                     if(!POIUtils.getBorderLeft(tmpCell).equals(BorderStyle.NONE)){
  1146.                                         break;
  1147.                                     }
  1148.                                     if(!POIUtils.isEmptyCellContents(tmpCell, config.getCellFormatter())){
  1149.                                         valueCell = tmpCell;
  1150.                                         break;
  1151.                                     }
  1152.                                 }
  1153.                             }
  1154.                         }

  1156.                         if(column.headerMerged() > 0){
  1157.                             hRow = hRow - column.headerMerged();
  1158.                         }

  1160.                         // 書き込む行が足りない場合の操作
  1161.                         if(emptyFlag) {
  1162.                             if(recordOperation.getAnnotation().overOperation().equals(OverOperation.Break)) {
  1163.                                 break;

  1165.                             } else if(recordOperation.getAnnotation().overOperation().equals(OverOperation.Copy)) {
  1166.                                 // 1つ左のセルの書式をコピーする。
  1167.                                 final CellStyle style = POIUtils.getCell(sheet, valueCell.getColumnIndex()-1, valueCell.getRowIndex()).getCellStyle();
  1168.                                 valueCell.setCellStyle(style);
  1169.                                 valueCell.setBlank();

  1171.                                 // セル幅の調整
  1172.                                 sheet.setColumnWidth(valueCell.getColumnIndex(), sheet.getColumnWidth(valueCell.getColumnIndex()-1));

  1174.                                 recordOperation.incrementCopyRecord();

  1176.                             } else if(recordOperation.getAnnotation().overOperation().equals(OverOperation.Insert)) {
  1177.                                 // POIは列の追加をサポートしていないので非対応。
  1178.                                 throw new AnnotationInvalidException(anno, MessageBuilder.create("anno.attr.notSupportValue")
  1179.                                         .var("property", accessor.getNameWithClass())
  1180.                                         .varWithAnno("anno", XlsRecordOption.class)
  1181.                                         .var("attrName", "overCase")
  1182.                                         .varWithEnum("attrValue", OverOperation.Insert)
  1183.                                         .format());
  1184.                             }

  1186.                         }

  1188.                         valueCellPositions.add(CellPosition.of(valueCell));

  1190.                         recordOperation.setupCellPositoin(valueCell);

  1192.                         if(!Utils.isSaveCase(column.cases())) {
  1193.                             continue;
  1194.                         }
  1195.                         // set for cell value
  1196.                         property.setPosition(record, CellPosition.of(valueCell));
  1197.                         property.setLabel(record, headerInfo.getLabel());
  1198.                         
  1199.                         final Cell tempCommentCell = valueCell;
  1200.                         property.getCommentGetter().ifPresent(getter -> config.getCommentOperator().saveCellComment(
  1201.                                 getter, tempCommentCell, record, accessor, config));

  1203.                         final CellConverter converter = converterCache.computeIfAbsent(property.getName(), key -> getCellConverter(property, config));
  1204.                         if(converter instanceof FieldFormatter) {
  1205.                             work.getErrors().registerFieldFormatter(property.getName(), property.getType(), (FieldFormatter<?>)converter, true);
  1206.                         }

  1208.                         try {
  1209.                             converter.toCell(property.getValue(record), record, sheet, CellPosition.of(valueCell));
  1210.                         } catch(TypeBindException e) {
  1211.                             work.addTypeBindError(e, valueCell, property.getName(), headerInfo.getLabel());
  1212.                             if(!config.isContinueTypeBindFailure()) {
  1213.                                 throw e;
  1214.                             }
  1215.                         }

  1217.                         // セルをマージする
  1218.                         if(column.merged() && (r > 0) && config.isMergeCellOnSave()) {
  1219.                             processSavingMergedCell(valueCell, sheet, mergedRanges, config);
  1220.                         }
  1221.                     }
  1222.                 }

  1224.                 /*
  1225.                  * 残りの行の操作
  1226.                  *  行の追加やコピー処理をしていないときのみ実行する
  1227.                  */
  1228.                 if(record == null && emptyFlag == false && recordOperation.isNotExecuteOverRecordOperation()) {
  1229.                     if(recordOperation.getAnnotation().remainedOperation().equals(RemainedOperation.None)) {
  1230.                         // なにもしない

  1232.                     } else if(recordOperation.getAnnotation().remainedOperation().equals(RemainedOperation.Clear)) {
  1233.                         Cell clearCell = POIUtils.getCell(sheet, hColumn, hRow);
  1234.                         clearCell.setBlank();

  1236.                     } else if(recordOperation.getAnnotation().remainedOperation().equals(RemainedOperation.Delete)) {
  1237.                         // POIは列の削除をサポートしていないので非対応。
  1238.                         throw new AnnotationInvalidException(anno, MessageBuilder.create("anno.attr.notSupportValue")
  1239.                                 .var("property", accessor.getNameWithClass())
  1240.                                 .varWithAnno("anno", XlsRecordOption.class)
  1241.                                 .var("attrName", "remainedOperation")
  1242.                                 .varWithEnum("attrValue", RemainedOperation.Delete)
  1243.                                 .format());
  1244.                     }
  1245.                 }

  1247.             }

  1249.             // マップ形式のカラムを出力する
  1250.             if(record != null) {
  1251.                 saveMapColumns(sheet, headers, valueCellPositions, CellPosition.of(initRow, hColumn), recordClass, record, terminal, anno, config, work, recordOperation);

  1253.                 saveArrayColumns(sheet, headers, valueCellPositions, CellPosition.of(initRow, hColumn), recordClass, record, terminal, anno, config, work, recordOperation);
  1254.             }

  1256.             // execute nested record.
  1257.             int skipSize = 0;
  1258.             if(record != null) {
  1259.                 skipSize = saveNestedRecords(sheet, headers, valueCellPositions, anno, CellPosition.of(initRow, hColumn), record,
  1260.                         config, work, mergedRanges, recordOperation);
  1261.                 nestedRecordSize.addAndGet(skipSize);
  1262.             }

  1264.             if(record != null) {

  1266.                 // set PostProcess listener
  1267.                 methodCache.getListenerClasses().forEach(listenerClass -> {
  1268.                     listenerClass.getPostSaveMethods().forEach(method -> {
  1269.                         work.addNeedPostProcess(new NeedProcess(record, listenerClass.getObject(), method));
  1270.                     });
  1271.                 });

  1273.                 // set PostProcess method
  1274.                 methodCache.getPostSaveMethods().forEach(method -> {
  1275.                     work.addNeedPostProcess(new NeedProcess(record, record, method));
  1276.                 });

  1278.             }

  1280.             // パスの位置の変更
  1281.             work.getErrors().popNestedPath();

  1283.             if(skipSize > 0) {
  1284.                 hColumn += skipSize;
  1285.             } else {
  1286.                 hColumn++;
  1287.             }

  1289.             if(emptyFlag == true && (r > result.size())) {
  1290.                 // セルが空で、書き込むデータがない場合。
  1291.                 break;
  1292.             }
  1293.         }

  1295.     }

  1297.     /**
  1298.      * 表の見出しから、レコードのJavaクラスの定義にあるカラムの定義で初めて見つかるリストのインデックスを取得する。
  1299.      * ・カラムの定義とは、アノテーション「@XlsColumn」が付与されたもの。
  1300.      * @param headers 表の見出し情報。
  1301.      * @param recordClass アノテーション「@XlsColumn」が定義されたフィールドを持つレコード用のクラス。
  1302.      * @param annoReader AnnotationReader
  1303.      * @param config システム設定
  1304.      * @return 引数「headers」の該当する要素のインデックス番号。不明な場合は、0を返す。
  1305.      */
  1306.     private int getStartHeaderIndexForSaving(final List<RecordHeader> headers, Class<?> recordClass,
  1307.             final AnnotationReader annoReader, final Configuration config) {

  1309.         // レコードクラスが不明の場合、0を返す。
  1310.         if((recordClass == null || recordClass.equals(Object.class))) {
  1311.             return 0;
  1312.         }

  1314.         for(int i=0; i < headers.size(); i++) {
  1315.             RecordHeader headerInfo = headers.get(i);
  1316.             final List<FieldAccessor> propeties = FieldAccessorUtils.getColumnPropertiesByName(
  1317.                     recordClass,annoReader, config,  headerInfo.getLabel())
  1318.                     .stream()
  1319.                     .filter(p -> p.isWritable())
  1320.                     .collect(Collectors.toList());
  1321.             if(!propeties.isEmpty()) {
  1322.                 return i;
  1323.             }
  1324.         }

  1326.         return 0;

  1328.     }

  1330.     /**
  1331.      * 上部のセルと同じ値の場合マージする
  1332.      * @param currentCell
  1333.      * @param sheet
  1334.      * @param mergedRanges
  1335.      * @return
  1336.      */
  1337.     private boolean processSavingMergedCell(final Cell currentCell, final Sheet sheet,
  1338.             final List<CellRangeAddress> mergedRanges, final Configuration config) {

  1340.         final int row = currentCell.getRowIndex();
  1341.         final int column = currentCell.getColumnIndex();

  1343.         if(column <= 0) {
  1344.             return false;
  1345.         }

  1347.         // 上のセルと比較する
  1348.         final String value = POIUtils.getCellContents(currentCell, config.getCellFormatter());
  1349.         String upperValue = POIUtils.getCellContents(POIUtils.getCell(sheet, column-1, row), config.getCellFormatter());

  1351.         // 結合されている場合、結合の先頭セルを取得する
  1352.         int startColumn = column - 1;
  1353.         CellRangeAddress currentMergedRange = null;
  1354.         for(CellRangeAddress range : mergedRanges) {
  1355.             // 列が範囲外の場合
  1356.             if((range.getFirstColumn() > startColumn) || (startColumn > range.getLastColumn())) {
  1357.                 continue;
  1358.             }

  1360.             // 行が範囲外の場合
  1361.             if((range.getFirstRow() > row) || (row > range.getLastRow())) {
  1362.                 continue;
  1363.             }

  1365.             upperValue = POIUtils.getCellContents(POIUtils.getCell(sheet, range.getFirstColumn(), row), config.getCellFormatter());
  1366.             currentMergedRange = range;
  1367.             break;
  1368.         }

  1370.         if(!value.equals(upperValue)) {
  1371.             // 値が異なる場合は結合しない
  1372.             return false;
  1373.         }

  1375.         // 既に結合済みの場合は一端解除する
  1376.         if(currentMergedRange != null) {
  1377.             startColumn = currentMergedRange.getFirstColumn();
  1378.             POIUtils.removeMergedRange(sheet, currentMergedRange);
  1379.         }

  1381.         final CellRangeAddress newRange = POIUtils.mergeCells(sheet, startColumn, row, column, row);
  1382.         mergedRanges.add(newRange);
  1383.         return true;

  1385.     }

  1387.     private void saveMapColumns(final Sheet sheet, final List<RecordHeader> headers, final List<CellPosition> valueCellPositions,
  1388.             final CellPosition beginPosition, final Class<?> recordClass, final Object record, final RecordTerminal terminal,
  1389.             final XlsVerticalRecords anno, final Configuration config, final SavingWorkObject work,
  1390.             final RecordOperation recordOperation) throws XlsMapperException {

  1392.         final List<FieldAccessor> properties = FieldAccessorUtils.getPropertiesWithAnnotation(
  1393.                 recordClass, work.getAnnoReader(), XlsMapColumns.class)
  1394.                 .stream()
  1395.                 .filter(p -> p.isReadable())
  1396.                 .collect(Collectors.toList());
  1397.         for(FieldAccessor property : properties) {

  1399.             final XlsMapColumns mapAnno = property.getAnnotationNullable(XlsMapColumns.class);

  1401.             Class<?> valueClass = mapAnno.valueClass();
  1402.             if(valueClass == Object.class) {
  1403.                 valueClass = property.getComponentType();
  1404.             }

  1406.             // get converter (map key class)
  1407.             final CellConverter converter = getCellConverter(valueClass, property, config);
  1408.             if(converter instanceof FieldFormatter) {
  1409.                 work.getErrors().registerFieldFormatter(property.getName(), valueClass, (FieldFormatter<?>)converter, true);
  1410.             }

  1412.             boolean foundPreviousColumn = false;
  1413.             for(RecordHeader headerInfo : headers) {
  1414.                 int hRow = beginPosition.getRow() + headerInfo.getInterval();
  1415.                 if(Utils.matches(headerInfo.getLabel(), mapAnno.previousColumnName(), config)){
  1416.                     foundPreviousColumn = true;
  1417.                     hRow++;
  1418.                     continue;
  1419.                 }

  1421.                 if(Utils.isNotEmpty(mapAnno.nextColumnName()) && Utils.matches(headerInfo.getLabel(), mapAnno.nextColumnName(), config)) {
  1422.                     break;
  1423.                 }

  1425.                 if(foundPreviousColumn) {
  1426.                     final Cell cell = POIUtils.getCell(sheet, beginPosition.getColumn(), hRow);

  1428.                     // 空セルか判断する
  1429.                     boolean emptyFlag = true;
  1430.                     if(terminal == RecordTerminal.Border) {
  1431.                         if(!POIUtils.getBorderTop(cell).equals(BorderStyle.NONE)) {
  1432.                             emptyFlag = false;
  1433.                         } else {
  1434.                             emptyFlag = true;
  1435.                         }
  1436.                     }

  1438.                     if(!anno.terminateLabel().equals("")) {
  1439.                         if(Utils.matches(POIUtils.getCellContents(cell, config.getCellFormatter()), anno.terminateLabel(), config)) {
  1440.                             emptyFlag = true;
  1441.                         }
  1442.                     }

  1444.                     // 空セルの場合
  1445.                     if(emptyFlag) {
  1446.                         if(recordOperation.getAnnotation().overOperation().equals(OverOperation.Break)) {
  1447.                             break;

  1449.                         } else if(recordOperation.getAnnotation().overOperation().equals(OverOperation.Copy)) {
  1450.                             final CellStyle style = POIUtils.getCell(sheet, cell.getColumnIndex()-1, cell.getRowIndex()).getCellStyle();
  1451.                             cell.setCellStyle(style);
  1452.                             cell.setBlank();

  1454.                         } else if(recordOperation.getAnnotation().overOperation().equals(OverOperation.Insert)) {
  1455.                             // POIは列の追加をサポートしていないので非対応。
  1456.                             throw new AnnotationInvalidException(anno, MessageBuilder.create("anno.attr.notSupportValue")
  1457.                                     .var("property", property.getNameWithClass())
  1458.                                     .varWithAnno("anno", XlsRecordOption.class)
  1459.                                     .var("attrName", "overCase")
  1460.                                     .varWithEnum("attrValue", OverOperation.Insert)
  1461.                                     .format());

  1463.                         }
  1464.                     }

  1466.                     valueCellPositions.add(CellPosition.of(cell));

  1468.                     recordOperation.setupCellPositoin(cell);

  1470.                     if(!Utils.isSaveCase(mapAnno.cases())) {
  1471.                         continue;
  1472.                     }

  1474.                     // セルの値を出力する
  1475.                     property.setMapPosition(record, CellPosition.of(cell), headerInfo.getLabel());
  1476.                     property.setMapLabel(record, headerInfo.getLabel(), headerInfo.getLabel());
  1477.                     
  1478.                     property.getMapCommentGetter().ifPresent(getter -> config.getCommentOperator().saveMapCellComment(
  1479.                             getter, cell, record, headerInfo.getLabel(), property, config));

  1481.                     try {
  1482.                         Object value = property.getValueOfMap(headerInfo.getLabel(), record);
  1483.                         converter.toCell(value, record, sheet, CellPosition.of(cell));
  1484.                     } catch(TypeBindException e) {
  1485.                         work.addTypeBindError(e, cell, String.format("%s[%s]", property.getName(), headerInfo.getLabel()), headerInfo.getLabel());
  1486.                         if(!config.isContinueTypeBindFailure()) {
  1487.                             throw e;
  1488.                         }
  1489.                     }
  1490.                 }

  1492.             }
  1493.         }

  1495.     }

  1497.     private void saveArrayColumns(final Sheet sheet, final List<RecordHeader> headers, final List<CellPosition> valueCellPositions,
  1498.             final CellPosition beginPosition, Class<?> recordClass, Object record, RecordTerminal terminal,
  1499.             XlsVerticalRecords anno, Configuration config, SavingWorkObject work,
  1500.             RecordOperation recordOperation) throws XlsMapperException {


  1503.         for(RecordHeader headerInfo : headers) {
  1504.             int hRow = beginPosition.getRow() + headerInfo.getInterval();

  1506.             // アノテーション「@XlsArrayColumns」の属性「columnName」と一致するプロパティを取得する。
  1507.             final List<FieldAccessor> arrayProperties = FieldAccessorUtils.getArrayColumnsPropertiesByName(
  1508.                     recordClass, work.getAnnoReader(), config, headerInfo.getLabel())
  1509.                     .stream()
  1510.                     .filter(f -> f.isReadable())
  1511.                     .collect(Collectors.toList());

  1513.             if(arrayProperties.isEmpty()) {
  1514.                 continue;
  1515.             }

  1517.             for(FieldAccessor property : arrayProperties) {

  1519.                 final XlsArrayColumns arrayAnno = property.getAnnotationNullable(XlsArrayColumns.class);

  1521.                 Class<?> elementClass = arrayAnno.elementClass();
  1522.                 if(elementClass == Object.class) {
  1523.                     elementClass = property.getComponentType();
  1524.                 }
  1525.                 final CellPosition initPosition = CellPosition.of(hRow, beginPosition.getColumn());

  1527.                 // 書き込む領域について、上のセルをコピーなどする。
  1528.                 int iRow = initPosition.getRow();
  1529.                 for(int i=0; i < arrayAnno.size(); i++) {
  1530.                     final Cell cell = POIUtils.getCell(sheet, initPosition.getColumn(), iRow);

  1532.                     // 空セルか判断する - 値のセルかどうか
  1533.                     boolean emptyFlag = true;

  1535.                     if(terminal == RecordTerminal.Border) {
  1536.                         if(!POIUtils.getBorderTop(cell).equals(BorderStyle.NONE)) {
  1537.                             emptyFlag = false;
  1538.                         } else {
  1539.                             emptyFlag = true;
  1540.                         }
  1541.                     }

  1543.                     if(!anno.terminateLabel().equals("")) {
  1544.                         if(Utils.matches(POIUtils.getCellContents(cell, config.getCellFormatter()), anno.terminateLabel(), config)) {
  1545.                             emptyFlag = true;
  1546.                         }
  1547.                     }

  1549.                     // 空セルの場合
  1550.                     if(emptyFlag) {
  1551.                         if(recordOperation.getAnnotation().overOperation().equals(OverOperation.Break)) {
  1552.                             break;

  1554.                         } else if(recordOperation.getAnnotation().overOperation().equals(OverOperation.Copy)) {
  1555.                             final Cell fromCell = POIUtils.getCell(sheet, cell.getColumnIndex()-1, cell.getRowIndex());
  1556.                             copyCellStyle(fromCell, cell);

  1558.                         } else if(recordOperation.getAnnotation().overOperation().equals(OverOperation.Insert)) {
  1559.                             // POIは列の追加をサポートしていないので非対応。
  1560.                             throw new AnnotationInvalidException(anno, MessageBuilder.create("anno.attr.notSupportValue")
  1561.                                     .var("property", property.getNameWithClass())
  1562.                                     .varWithAnno("anno", XlsRecordOption.class)
  1563.                                     .var("attrName", "overCase")
  1564.                                     .varWithEnum("attrValue", OverOperation.Insert)
  1565.                                     .format());


  1568.                         }
  1569.                     }

  1571.                     // 結合情報を考慮して、インデックス（列番号）を次のセルに進める。
  1572.                     if(arrayAnno.elementMerged()) {
  1573.                         final CellRangeAddress mergedRegion = POIUtils.getMergedRegion(sheet, cell.getRowIndex(), cell.getColumnIndex());
  1574.                         if(mergedRegion != null) {
  1575.                             iRow += POIUtils.getRowSize(mergedRegion);
  1576.                         } else {
  1577.                             iRow++;
  1578.                         }

  1580.                     } else {
  1581.                         iRow++;
  1582.                     }

  1584.                     recordOperation.setupCellPositoin(cell);
  1585.                 }

  1587.                 if(!Utils.isSaveCase(arrayAnno.cases())) {
  1588.                     continue;
  1589.                 }

  1591.                 // get converter (component class)
  1592.                 final CellConverter<?> converter = getCellConverter(elementClass, property, config);
  1593.                 if(converter instanceof FieldFormatter) {
  1594.                     work.getErrors().registerFieldFormatter(property.getName(), elementClass, (FieldFormatter<?>)converter, true);
  1595.                 }

  1597.                 ArrayCellsHandler arrayHandler = new ArrayCellsHandler(property, record, elementClass, sheet, config);
  1598.                 arrayHandler.setLabel(headerInfo.getLabel());

  1600.                 final Class<?> propertyType = property.getType();
  1601.                 final Object result = property.getValue(record);

  1603.                 if(result != null) {
  1604.                     // インデックスが付いていないラベルの設定
  1605.                     property.setLabel(record, headerInfo.getLabel());
  1606.                 }

  1608.                 if(Collection.class.isAssignableFrom(propertyType)) {

  1610.                     final Collection<Object> value = (result == null ? new ArrayList<Object>() : (Collection<Object>) result);
  1611.                     final List<Object> list = Utils.convertCollectionToList(value);
  1612.                     arrayHandler.handleOnSaving(list, arrayAnno, initPosition, converter, work, ArrayDirection.Vertical);

  1614.                 } else if(propertyType.isArray()) {

  1616.                     final List<Object> list = Utils.asList(result, elementClass);
  1617.                     arrayHandler.handleOnSaving(list, arrayAnno, initPosition, converter, work, ArrayDirection.Vertical);
  1618.                 }

  1620.             }
  1621.         }

  1623.     }

  1625.     /**
  1626.      * セルの書式をコピーする。
  1627.      * <p>コピー先のセルの種類は、空セルとする。</p>
  1628.      * <p>結合情報も列方向の結合をコピーする。</p>
  1629.      *
  1630.      * @since 2.0
  1631.      * @param fromCell コピー元
  1632.      * @param toCell コピー先
  1633.      */
  1634.     private void copyCellStyle(final Cell fromCell, final Cell toCell) {

  1636.         final CellStyle style = fromCell.getCellStyle();
  1637.         toCell.setCellStyle(style);
  1638.         toCell.setBlank();

  1640.         // 縦方向に結合されている場合、結合情報のコピーする。（XlsArrayColumns用）
  1641.         final Sheet sheet = fromCell.getSheet();
  1642.         final CellRangeAddress mergedRegion = POIUtils.getMergedRegion(sheet, fromCell.getRowIndex(), fromCell.getColumnIndex());
  1643.         final int mergedSize = POIUtils.getRowSize(mergedRegion);

  1645.         if(mergedSize >= 2) {
  1646.             CellRangeAddress newMergedRegion = POIUtils.getMergedRegion(sheet, toCell.getRowIndex(), toCell.getColumnIndex());
  1647.             if(newMergedRegion != null) {
  1648.                 // 既に結合している場合 - 通常はありえない。
  1649.                 return;
  1650.             }

  1652.             newMergedRegion = POIUtils.mergeCells(sheet,
  1653.                     toCell.getColumnIndex(), mergedRegion.getFirstRow(), toCell.getColumnIndex(), mergedRegion.getLastRow());

  1655.             // 結合先のセルの書式も設定する
  1656.             for(int i=1; i < mergedSize; i++) {
  1657.                 Cell mergedFromCell = POIUtils.getCell(sheet, fromCell.getColumnIndex(), toCell.getRowIndex()+i);

  1659.                 Cell mergedToCell = POIUtils.getCell(sheet, toCell.getColumnIndex(), toCell.getRowIndex()+i);
  1660.                 mergedToCell.setCellStyle(mergedFromCell.getCellStyle());
  1661.                 mergedToCell.setBlank();
  1662.             }
  1663.         }

  1665.     }

  1667.     @SuppressWarnings("unchecked")
  1668.     private int saveNestedRecords(final Sheet sheet, final List<RecordHeader> headers, final List<CellPosition> valueCellPositions,
  1669.             final XlsVerticalRecords anno,
  1670.             final CellPosition beginPositoin,
  1671.             final Object record,
  1672.             final Configuration config, final SavingWorkObject work,
  1673.             final List<CellRangeAddress> mergedRanges, final RecordOperation recordOperation) throws XlsMapperException {

  1675.         int skipSize = 0;

  1677.         final List<FieldAccessor> nestedProperties = FieldAccessorUtils.getPropertiesWithAnnotation(
  1678.                 record.getClass(), work.getAnnoReader(), XlsNestedRecords.class)
  1679.                 .stream()
  1680.                 .filter(p -> p.isReadable())
  1681.                 .collect(Collectors.toList());
  1682.         
  1683.         for(FieldAccessor property : nestedProperties) {

  1685.             final XlsNestedRecords nestedAnno = property.getAnnotationNullable(XlsNestedRecords.class);

  1687.             if(!Utils.isSaveCase(nestedAnno.cases())) {
  1688.                 continue;
  1689.             }

  1691.             final Class<?> clazz = property.getType();
  1692.             if(Collection.class.isAssignableFrom(clazz)) {
  1693.                 // mapping by one-to-many

  1695.                 Class<?> recordClass = nestedAnno.recordClass();
  1696.                 if(recordClass == Object.class) {
  1697.                     recordClass = property.getComponentType();
  1698.                 }

  1700.                 Collection<Object> value = (Collection<Object>) property.getValue(record);
  1701.                 if(value == null) {
  1702.                     // dummy empty record
  1703.                     value = (Collection<Object>) Arrays.asList(config.createBean(recordClass));
  1704.                 }

  1706.                 final List<Object> list = Utils.convertCollectionToList(value);
  1707.                 final AtomicInteger nestedRecordSize = new AtomicInteger(0);
  1708.                 saveRecords(sheet, headers, anno, beginPositoin, nestedRecordSize, property, recordClass, list,
  1709.                         config, work, mergedRanges, recordOperation);

  1711.                 if(skipSize < list.size()) {
  1712.                     if(nestedRecordSize.get() > 0) {
  1713.                         skipSize = nestedRecordSize.get() - skipSize;
  1714.                     } else {
  1715.                         skipSize = list.size();
  1716.                     }
  1717.                 }

  1719.                 processSavingNestedMergedRecord(sheet, skipSize, valueCellPositions);

  1721.             } else if(clazz.isArray()) {

  1723.                 // mapping by one-to-many

  1725.                 Class<?> recordClass = nestedAnno.recordClass();
  1726.                 if(recordClass == Object.class) {
  1727.                     recordClass = property.getComponentType();
  1728.                 }

  1730.                 Object[] value = (Object[])property.getValue(record);
  1731.                 if(value == null) {
  1732.                     // dummy empty record
  1733.                     value = new Object[]{config.createBean(recordClass)};
  1734.                 }

  1736.                 final List<Object> list = Arrays.asList(value);
  1737.                 final AtomicInteger nestedRecordSize = new AtomicInteger(0);
  1738.                 saveRecords(sheet, headers, anno, beginPositoin, nestedRecordSize, property, recordClass, list,
  1739.                         config, work, mergedRanges, recordOperation);

  1741.                 if(nestedRecordSize.get() > 0) {
  1742.                     skipSize = nestedRecordSize.get() - skipSize;
  1743.                 } else {
  1744.                     skipSize = list.size();
  1745.                 }

  1747.                 processSavingNestedMergedRecord(sheet, skipSize, valueCellPositions);

  1749.             } else {

  1751.                 // mapping by one-to-many
  1752.                 Class<?> recordClass = anno.recordClass();
  1753.                 if(recordClass == Object.class) {
  1754.                     recordClass = property.getType();
  1755.                 }

  1757.                 Object value = property.getValue(record);
  1758.                 if(value == null) {
  1759.                     // dummy empty record
  1760.                     value = config.createBean(recordClass);
  1761.                 }

  1763.                 List<Object> list = Arrays.asList(value);
  1764.                 final AtomicInteger nestedRecordSize = new AtomicInteger(0);
  1765.                 saveRecords(sheet, headers, anno, beginPositoin, nestedRecordSize, property, recordClass, list,
  1766.                         config, work, mergedRanges, recordOperation);

  1768.                 if(nestedRecordSize.get() > 0) {
  1769.                     skipSize = nestedRecordSize.get() - skipSize;
  1770.                 } else {
  1771.                     skipSize = list.size();
  1772.                 }

  1774.             }
  1775.         }

  1777.         return skipSize;
  1778.     }

  1780.     /**
  1781.      * ネストしたレコードの親のセルを結合する
  1782.      * @param sheet シート
  1783.      * @param mergedSize 結合するセルのサイズ
  1784.      * @param valueCellPositions 結合する開始位置のセルのアドレス
  1785.      */
  1786.     private void processSavingNestedMergedRecord(final Sheet sheet, final int mergedSize,
  1787.             final List<CellPosition> valueCellPositions) {

  1789.         if(mergedSize <= 1) {
  1790.             return;
  1791.         }

  1793.         // ネストした場合、上のセルのスタイルをコピーして、結合する
  1794.         for(CellPosition position : valueCellPositions) {
  1795.             Cell valueCell = POIUtils.getCell(sheet, position);
  1796.             if(valueCell == null) {
  1797.                 continue;
  1798.             }

  1800.             final CellStyle style = valueCell.getCellStyle();

  1802.             // 結合するセルに対して、上のセルのスタイルをコピーする。
  1803.             // 列を挿入するときなどに必要になるため、スタイルを設定する。
  1804.             for(int i=1; i < mergedSize; i++) {
  1805.                 Cell mergedCell = POIUtils.getCell(sheet, position.getColumn() + i, position.getRow());
  1806.                 mergedCell.setCellStyle(style);
  1807.                 mergedCell.setBlank();
  1808.             }

  1810.             final CellRangeAddress range = new CellRangeAddress(position.getRow(), position.getRow(),
  1811.                     position.getColumn(), position.getColumn() + mergedSize -1);

  1813.             // 既に結合済みのセルがある場合、外す。
  1814.             for(int colIdx=range.getFirstColumn(); colIdx <= range.getLastColumn(); colIdx++) {
  1815.                 CellRangeAddress r = POIUtils.getMergedRegion(sheet, position.getRow(), colIdx);
  1816.                 if(r != null) {
  1817.                     POIUtils.removeMergedRange(sheet, r);
  1818.                 }
  1819.             }

  1821.             sheet.addMergedRegion(range);
  1822.         }

  1824.     }

  1826.     /**
  1827.      * セルの入力規則の範囲を修正する。
  1828.      * @param sheet
  1829.      * @param recordOperation
  1830.      */
  1831.     private void correctDataValidation(final Sheet sheet, final RecordOperation recordOperation) {

  1833.         if(recordOperation.isNotExecuteRecordOperation()) {
  1834.             return;
  1835.         }

  1837.         //TODO: セルの結合も考慮する

  1839.         // 操作をしていないセルの範囲の取得
  1840.         final CellRangeAddress notOperateRange = new CellRangeAddress(
  1841.                 recordOperation.getTopLeftPoisitoin().y,
  1842.                 recordOperation.getBottomRightPosition().y,
  1843.                 recordOperation.getTopLeftPoisitoin().x,
  1844.                 recordOperation.getBottomRightPosition().x - recordOperation.getCountInsertRecord()
  1845.                 );

  1847.         final List<? extends DataValidation> list = sheet.getDataValidations();
  1848.         for(DataValidation validation : list) {

  1850.             final CellRangeAddressList region = validation.getRegions().copy();
  1851.             boolean changedRange = false;
  1852.             for(CellRangeAddress range : region.getCellRangeAddresses()) {

  1854.                 if(notOperateRange.isInRange(range.getFirstRow(), range.getFirstColumn())) {
  1855.                     // 自身のセルの範囲の場合は、行の範囲を広げる
  1856.                     range.setLastColumn(recordOperation.getBottomRightPosition().x);
  1857.                     changedRange = true;

  1859.                 } else if(notOperateRange.getLastColumn() < range.getFirstColumn()) {
  1860.                     /*
  1861.                      * VerticalRecordsの場合は、挿入・削除はないので、自身以外の範囲は修正しない。
  1862.                      */
  1863.                 }

  1865.             }

  1867.             // 修正した規則を、再度シートに追加する
  1868.             if(changedRange) {
  1869.                 boolean updated = POIUtils.updateDataValidationRegion(sheet, validation.getRegions(), region);
  1870.                 assert updated == true;
  1871.             }
  1872.         }

  1874.     }

  1876.     /**
  1877.      * 名前の定義の範囲を修正する。
  1878.      * @param sheet
  1879.      * @param recordOperation
  1880.      */
  1881.     private void correctNameRange(final Sheet sheet, final RecordOperation recordOperation) {

  1883.         if(recordOperation.isNotExecuteRecordOperation()) {
  1884.             return;
  1885.         }

  1887.         final Workbook workbook = sheet.getWorkbook();
  1888.         final int numName = workbook.getNumberOfNames();
  1889.         if(numName == 0) {
  1890.             return;
  1891.         }

  1893.         // 操作をしていないセルの範囲の取得
  1894.         final CellRangeAddress notOperateRange = new CellRangeAddress(
  1895.                 recordOperation.getTopLeftPoisitoin().y,
  1896.                 recordOperation.getBottomRightPosition().y,
  1897.                 recordOperation.getTopLeftPoisitoin().x,
  1898.                 recordOperation.getBottomRightPosition().x - recordOperation.getCountInsertRecord()
  1899.                 );

  1901.         for(Name name : workbook.getAllNames()) {

  1903.             if(name.isDeleted() || name.isFunctionName()) {
  1904.                 // 削除されている場合、関数の場合はスキップ
  1905.                 continue;
  1906.             }

  1908.             if(!sheet.getSheetName().equals(name.getSheetName())) {
  1909.                 // 自身のシートでない名前は、修正しない。
  1910.                 continue;
  1911.             }

  1913.             AreaReference areaRef = new AreaReference(name.getRefersToFormula(), POIUtils.getVersion(sheet));
  1914.             CellReference firstCellRef = areaRef.getFirstCell();
  1915.             CellReference lastCellRef = areaRef.getLastCell();

  1917.             if(notOperateRange.isInRange(firstCellRef.getRow(), firstCellRef.getCol())) {
  1918.                 // 自身のセルの範囲の場合は、行の範囲を広げる。

  1920.                 lastCellRef= new CellReference(
  1921.                         lastCellRef.getSheetName(),
  1922.                         lastCellRef.getRow(), recordOperation.getBottomRightPosition().x,
  1923.                         lastCellRef.isRowAbsolute(), lastCellRef.isColAbsolute());
  1924.                 areaRef = new AreaReference(firstCellRef, lastCellRef, sheet.getWorkbook().getSpreadsheetVersion());

  1926.                 // 修正した範囲を再設定する
  1927.                 name.setRefersToFormula(areaRef.formatAsString());

  1929.             } else if(notOperateRange.getLastColumn() < firstCellRef.getCol()) {
  1930.                 /*
  1931.                  * 名前の定義の場合、自身のセルノ範囲より右方にあるセルの範囲の場合、
  1932.                  * 自動的に修正されるため、修正は必要なし。
  1933.                  */

  1935.             }

  1937.         }

  1939.     }

  1941. }
Created with JaCoCo 0.8.5.201910111838