Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright [2013] [www.rapidpm.org / Sven Ruppert (sven.ruppert@rapidpm.org)]
   *
   *    Licensed under the Apache License, Version 2.0 (the "License");
   *    you may not use this file except in compliance with the License.
   *    You may obtain a copy of the License at
   *
   *        http://www.apache.org/licenses/LICENSE-2.0
   *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
 
 package org.rapidpm.data.table.impl;
NeoScio User: svenruppert Date: 28.10.2009 Time: 01:13:44 This Source Code is part of the www.svenruppert.de project. please contact sven.ruppert@web.de
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
Diese Klasse sollte immer über den TableCreator erzeugt und befüllt werden.
 
 public class TableImpl implements Table {
     private static final Logger logger = Logger.getLogger(TableImpl.class);
 
     private String tableName = "";
     private String fileName = null;
 
     private int sortColNr = 0;
     private boolean sortColDirection = true;
 
     //private Map<String, ColumnInformation> colInfoMap = new HashMap<String, ColumnInformation>();
     private final List<ColumnInformationcolumnInfoList = new ArrayList<>();
     private transient final Map<StringIntegercolumnInfoIndex = new HashMap<>();
 
     private final List<RowrowList = new ArrayList<>();
     private final List<RowValidatorrowValidatorList = new ArrayList<>();
 
 
     @Override
     public Row getRow(final int index) {
         return .get(index);
     }
 
     @Override
     public void removeRow(final int index) {
         .remove(index);
         for (final ColumnInformation ci : ) {
             //JIRA MOD-33 zellen direkt löschen
             final List zellen = ci.getZellen();
             if (zellen.size() > index) {
                 zellen.remove(index);
             }
         }
     }
 
     @Override
     public ColumnInformation getColumnInformationFor(final int index) {
         return .get(index);
     }
 
     @Override
     public SoapTable exportAsSoapTable() {
         final SoapTableCreator creator = new SoapTableCreator() {
             @Override
            public void addAllColInfoEntries() {
                final Collection<ColumnInformationcolumnInfoList = getColumnInfoList();
                for (final ColumnInformation columnInformation : columnInfoList) {
                    //JIRA MOD-34 Col Typeinfo fehlt noch
                    // final Cell cell = (Cell) columnInformation.getZellen().get(0);
                    // cell.is
//                    addColInfo(columnInformation.getSpaltenName(), SoapTable.ColInfoType.STRING); //CellValueMapping
                    addColInfo(columnInformation.getSpaltenName()); //CellValueMapping
                }
            }
            @Override
            public void addAllColEntries() {
                final List<Rowrows = getRowList();
                for (final Row row : rows) {
                    startNewRow();
                    final List<Cellcells = row.getCells();
                    for (final Cell cell : cells) {
                        addColEntry(cell.getFormattedValue());
                    }
                    stopNewRow();
                }
            }
        };
        return creator.execute().getTable();
    }
    @Override
    public boolean isEmpty() {
        return .isEmpty();
    }
    @Override
    public boolean isNotEmpty() {
        return !.isEmpty();
    }
    @Override
    public Iterator<Rowiterator() {
        return .iterator();
    }
    @Override
    public void setColInfo(final String colNamefinal ColumnInformation columnInformation) {
        .add(columnInformation);
        .put(colName.size() - 1);
    }
    @Override
    public String getTableName() {
        return ;
    }
    @Override
    public void setTableName(final String tableName) {
        this. = tableName;
    }
    public String getFileName() {
        return ;
    }
    public void setFileName(final String fileName) {
        this. = fileName;
    }
    @Override
    public Map<StringColumnInformationgetColInfoMap() {
        final Map<StringColumnInformationcolInfoMap = new HashMap<>();
        for (final ColumnInformation columnInformation : ) {
            colInfoMap.put(columnInformation.getSpaltenName(), columnInformation);
        }
        return colInfoMap;
    }
    @Override
    public int getRowCount() {
        return .size();
    }
    @Override
    public void setSortCol(final int colNrfinal boolean asc) {
        this. = colNr;
        this. = asc;
    }

    
rekursiv alle Spalten neu ordnen
    @Override
    public void reorderCols() {
    }

    
rekursiv alle Zeilen sortieren
    @Override
    public void reorderRows(final int colNrfinal boolean asc) {
        setSortCol(colNrasc);
        reorderRowsImpl();
    }
    private void reorderRowsImpl() {
        if (isEmpty()) {
            if (.isDebugEnabled()) {
                .debug("Tabelle ist leer...");
            }
        } else {
            final List<CellcellListe = new ArrayList<>();
            for (final Row row : ) {
                final List<CellcellList = row.getCells();
                if (cellList.isEmpty()) {
                    if (.isDebugEnabled()) {
                        .debug("Cell List der Row ist leer.");
                    }
                } else {
                    final int index =  - 1;
                    final Cell cell = cellList.get(index);
                    cellListe.add(cell);
                }
            }
            //finde den Comparator
            if (!cellListe.isEmpty()) {
                final Cell cell = cellListe.get(0);
                final ColumnInformation information = cell.getColInfo();
                final ZellenComparator zellenComparator = information.getZellenComparator();
                zellenComparator.setSortASC();
                final boolean sortValue = information.isSortValue();
                zellenComparator.setSortValue(sortValue);
                Collections.sort(cellListezellenComparator); //JIRA MOD-35 Vererbung nicht sauber , ZellenComparator
                final List<IntegeridListe = new ArrayList<>();
                for (final Cell cellTmp : cellListe) {
                    idListe.add(cellTmp.getRow().getRowNr());
                }
                final List<RowrowListNew = new ArrayList<>();
                for (final Integer rowId : idListe) {
                    rowListNew.add(.get(rowId));
                }
                .clear();
                .addAll(rowListNew);
            } else {
                if (.isDebugEnabled()) {
                    .debug("CellList ist leer.");
                }
            }
            //ID s neu setzten ?????
            int i = 0;
            for (final Row row : ) {
                row.setRowNr(i);
                i++;
            }
        }
    }

    
rekursiv alle Zellen in allen Zeilen sortieren
    @Override
    public void reorderCellsInAllRows() {
        for (final Row row : ) {
            row.reorderCells();
        }
    }

    
Fuerg eine neue Zeile hinzu. Es wird nicht auf doppelten Datensaetze ueberpruft. Nr der zeile ist immer, Aktuelle Anzahl plus eins.

Parameters:
zeile
    @Override
    public void addRow(final Row zeile) {
        zeile.setRowNr(.size());
        .add(zeile);
    }
    @Override
    public void insertRow(final int indexfinal Row row) {
        row.setRowNr(index);
        .add(indexrow);
        // nachfolgende Zeilennummern nach unten schieben
        for (int i = index + 1; i < .size(); i++) {
            .get(i).setRowNr(i);
        }
    }
    @Override
    public void insertRow(final int index) {
        final Row row = createEmptyRow();
        row.setRowNr(index);
        insertRow(indexrow);
    }
    @Override
    public void addNextColInfo(final String colNamefinal Class clazzfinal ColumnProperty... properties) {
        final EnumSet<ColumnPropertycolumnFlags = EnumSet.noneOf(ColumnProperty.class);
        columnFlags.addAll(Arrays.asList(properties));
        addNextColInfo(colNameclazzcolumnFlags);
    }
    @Override
    public void addNextColInfo(String colNameClass clazzCellValueFormatter cellValueFormatterColumnProperty... properties) {
        final EnumSet<ColumnPropertycolumnFlags = EnumSet.noneOf(ColumnProperty.class);
        columnFlags.addAll(Arrays.asList(properties));
        addNextColInfo(colNameclazzcellValueFormattercolumnFlags);
    }
    public void addNextColInfo(final String colNamefinal Class clazzfinal EnumSet<ColumnPropertyflags) {
        final ColumnInformation columnInformation = createColumnInformation(colNameclazzflags);
        setColInfo(colNamecolumnInformation);
    }
    public void addNextColInfo(final String colNamefinal Class clazzfinal CellValueFormatter cellValueFormatterfinal EnumSet<ColumnPropertyflags) {
        final ColumnInformation columnInformation = createColumnInformation(colNameclazzflags);
        columnInformation.setFormatter(cellValueFormatter);
        setColInfo(colNamecolumnInformation);
    }
    private ColumnInformation createColumnInformation(String colNameClass clazzEnumSet<ColumnPropertyflags) {
        final int colNr = getColInfoMap().size() + 1;
        final ColumnInformation columnInformation = ColumnInformation.newInstance(colNamecolNrclazz);
        columnInformation.setSortable(flags.contains(.));
        columnInformation.setEditable(flags.contains(.));
        columnInformation.setExportable(!flags.contains(.));
        columnInformation.setSortValue(!flags.contains(.));
        columnInformation.setVisible(!flags.contains(.));
        return columnInformation;
    }
    // REFAC methode entfernen ?
    @Override
    public void addNextCell(final String colNamefinal Cell newCellfinal Row activeRow) {
        if (newCell != null) {
            connectColInfo(colNamenewCellactiveRow);
        } else {
            if (.isDebugEnabled()) {
                .debug("addNextCell (2) Value == null ");
            }
        }
    }
    private void connectColInfo(final String colNamefinal Cell newCellfinal Row activeRow) {
        final Map<StringColumnInformationcolInfoMap = this.getColInfoMap();
        if (colInfoMap.containsKey(colName)) {
            final ColumnInformation information = colInfoMap.get(colName);
            newCell.setColInfo(information);
            information.getZellen().add(newCell);
            activeRow.addCell(newCell);
        } else {
            if (.isDebugEnabled()) {
                .debug("Angegebene Col nicht definiert " + colName);
            }
        }
    }
    @Override
        return Collections.unmodifiableList();
        //        final Row row = rowList.get(0);
        //        final List<Cell> cellList = row.getCells();
        //        final List<ColumnInformation> colInfoList = new ArrayList<ColumnInformation>();
        //        for (Cell cell : cellList) {
        //            colInfoList.add(cell.getColInfo());
        //        }
//        final Collection<ColumnInformation> informationCollection = colInfoMap.values();
//        final List<ColumnInformation> colInfoList = new ArrayList<ColumnInformation>();
//        colInfoList.addAll(informationCollection);
//        Collections.sort(colInfoList, new ColumnInformation.SpaltenInformationenComparator());
//        return colInfoList;
    }
    @Override
    public boolean hasColumn(final String colName) {
        return .containsKey(colName);
    }
    @Override
    public ColumnInformation getColumnInformationFor(final String colName) {
        return .get(.get(colName));
    }
    @Override
    public Set<StringgetColumnNames() {
        return .keySet();
    }
    @Override
    public boolean changeColumnName(final String oldNamefinal String newName) {
        if (oldName.equals(newName)) {
            return true;
        }
        if (hasColumn(oldName) && !hasColumn(newName)) {
            final Integer colIndex = .remove(oldName);
            .get(colIndex).setSpaltenName(newName);
            .put(newNamecolIndex);
            return true;
        } else {
            return false;
        }
    }
    @Override
    public int getColumnCount() {
        return .size();
    }
    @Override
    public int getVisibleColumnCount() {
        int count = 0;
        for (final ColumnInformation columnInformation : ) {
            if (columnInformation.isVisible()) {
                count++;
            }
        }
        return count;
    }
    @Override
    public int[] getVisibleColumnIndices() {
        final int[] indices = new int[getVisibleColumnCount()];
        for (int i = 0, vi = 0; i < getColumnCount(); i++) {
            final ColumnInformation colInfo = .get(i);
            if (colInfo.isVisible()) {
                indices[vi] = i;
                vi++;
            }
        }
        return indices;
    }
    @Override
        final ArrayList<ColumnInformationcolumnList = new ArrayList<>();
        for (final ColumnInformation columnInformation : ) {
            if (columnInformation.isVisible()) {
                columnList.add(columnInformation);
            }
        }
        return columnList;
    }
    @Override
    public List getUniqueValuesForCol(final String colName) {
        final List uniqueValues = new ArrayList();
        if (hasColumn(colName)) {
            final ColumnInformation columnInformation = getColumnInformationFor(colName);
            final HashSet valueSet = new HashSet();
            final List<Cellzellen = columnInformation.getZellen();
            for (final Cell cell : zellen) {
                valueSet.add(cell.getValue());
            }
            uniqueValues.addAll(valueSet);
        } else {
            if (.isDebugEnabled()) {
                .debug("Die Tabelle enthält nicht die Spalte " + colName);
            }
        }
        return uniqueValues;
    }
    @Override
    public List<RowgetRowList() {
        return ;
    }
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append("TableImpl");
        sb.append("{tableName='").append().append('\'');
        sb.append(", sortColNr=").append();
        sb.append(", sortColDirection=").append();
        sb.append(", columnInfoList=").append();
        sb.append(", columnInfoIndex=").append();
//        sb.append(", rowList=").append(rowList);
        sb.append(", rowValidatorList=").append();
        sb.append('}');
        return sb.toString();
    }
    @Override
    public Row createEmptyRow() {
        final Row row = new RowImpl();
        for (final ColumnInformation columnInformation : ) {
            final Cell newCell = new BaseCellFactory().createNewEmptyCell(columnInformation.getCellValueClass());
            connectColInfo(columnInformation.getSpaltenName(), newCellrow);
            row.addCell(newCell);
        }
        return row;
    }
    @Override
    public TableError validate() {
        final TableError error = new TableError();
        for (int rowIndex = 0; rowIndex < .size(); rowIndex++) {
            final Row row = .get(rowIndex);
            if (row.getCellCount() != getColumnCount()) {
                error.addError(new TableError.RowError(rowIndex"the cell count (" + row.getCellCount() +
                        ") does not match the column count (" + getColumnCount() + ") of this table"));
            }
            for (int cellIndex = 0; cellIndex < row.getCellCount(); cellIndex++) {
                final Cell cell = row.getCell(cellIndex);
                final ColumnInformation cellColInfo = cell.getColInfo();
                if (cell.getRow() != row) {
                    error.addError(new TableError.CellError(cellIndexrowIndex,
                            "the parent row of the cell does not match this row"));
                }
                if (cellIndex >= getColumnCount()) {
                    error.addError(new TableError.CellError(cellIndexrowIndex,
                            "the cell index is greater than the column count of this table (" + getColumnCount() + ")"));
                } else if (!cellColInfo.equals(.get(cellIndex))) {
                    error.addError(new TableError.CellError(cellIndexrowIndex,
                            "the column information of this cell do not match the column information of this table column"));
                } else if (cell.getCellValueClass() != cellColInfo.getCellValueClass()) {
                    error.addError(new TableError.CellError(cellIndexrowIndex,
                            "the cell value type (" + cell.getCellValueClass() + ") does not match ne column type (" +
                                    cellColInfo.getCellValueClass() + ")"));
                }
            }
        }
        if (.isDebugEnabled()) {
            .debug(getTableName() + " : " + error);
        }
        return error;
    }
    @Override
        return ;
    }
    @Override
    public void addRowValidator(final RowValidator rowValidator) {
        .add(rowValidator);
    }
New to GrepCode? Check out our FAQ X