#243

Committed 22 Sep 2023 01:08PM UTC coverage: 89.793% (-0.3%) from 90.043%

Build # #243

Build Type

push

Committed by

Commit Message

Added longest common sequence implementation.

Run Details

74 of 74 new or added lines in 2 files covered. (100.0%)

7495 of 8347 relevant lines covered (89.79%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.78

/lis-commons-util/src/main/java/com/link_intersystems/util/ArrayTable.java

package com.link_intersystems.util;

import java.lang.reflect.Array;

import static java.util.Objects.*;

/**
 * Resizable-array implementation of the {@code Table} interface.
 *
 * @param <E>
 */
public class ArrayTable<E> implements Table<E> {

    private final Class<E> elementType;
    private E[][] table;
    private E defaultCellValue;
    private int rowGrowSize = 16;
    private int columnGrowSize = 16;

    public ArrayTable(Class<E> elementType) {
        this(elementType, null);
    }

    public ArrayTable(Class<E> elementType, E defaultCellValue) {
        this.elementType = requireNonNull(elementType);
        table = (E[][]) Array.newInstance(elementType, 0, 0);
        this.defaultCellValue = defaultCellValue;
    }

    public void setRowGrowSize(int rowGrowSize) {
        if (rowGrowSize < 1) {
            throw new IllegalArgumentException();
        }
        this.rowGrowSize = rowGrowSize;
    }

    public void setColumnGrowSize(int columnGrowSize) {
        if (columnGrowSize < 1) {
            throw new IllegalArgumentException();
        }
        this.columnGrowSize = columnGrowSize;
    }

    @Override
    public E getCell(int row, int column) {
        E cellValue = null;

        if (table != null && row < table.length && column < table[row].length) {
            cellValue = table[row][column];
        }

        if (cellValue == null) {
            cellValue = defaultCellValue;
        }

        return cellValue;
    }

    @Override
    public E setCell(int row, int column, E element) {
        ensureCapacity(row, column);

        E previousElement = table[row][column];
        table[row][column] = element;
        return previousElement;
    }

    private void ensureCapacity(int row, int column) {
        if (row >= table.length) {
            E[][] newTable = growRows(row);

            for (int i = 0; i < table.length; i++) {
                newTable[i] = table[i];
            }

            table = newTable;
        }

        if (column >= table[row].length) {
            E[] newColumns = growColumns(row, column);
            System.arraycopy(table[row], 0, newColumns, 0, table[row].length);
            table[row] = newColumns;
        }
    }

    protected E[] growColumns(int row, int column) {
        int newSize = column + 1 + columnGrowSize;
        if (newSize < 0) {
            newSize = Integer.MAX_VALUE;
        }
        return (E[]) Array.newInstance(elementType, newSize);
    }

    protected E[][] growRows(int minRows) {
        int newSize = minRows + 1 + rowGrowSize;
        if (newSize < 0) {
            newSize = Integer.MAX_VALUE;
        }
        return (E[][]) Array.newInstance(elementType, newSize, 0);
    }

}

1	package com.link_intersystems.util;
2
3	import java.lang.reflect.Array;
4
5	import static java.util.Objects.*;
6
7	/**
8	* Resizable-array implementation of the {@code Table} interface.
9	*
10	* @param <E>
11	*/
12	public class ArrayTable<E> implements Table<E> {
13
14	private final Class<E> elementType;
15	private E[][] table;
16	private E defaultCellValue;
17	private int rowGrowSize = 16;	1✔
18	private int columnGrowSize = 16;	1✔
19
20	public ArrayTable(Class<E> elementType) {
21	this(elementType, null);	1✔
22	}	1✔
23
24	public ArrayTable(Class<E> elementType, E defaultCellValue) {	1✔
25	this.elementType = requireNonNull(elementType);	1✔
26	table = (E[][]) Array.newInstance(elementType, 0, 0);	1✔
27	this.defaultCellValue = defaultCellValue;	1✔
28	}	1✔
29
30	public void setRowGrowSize(int rowGrowSize) {
31	if (rowGrowSize < 1) {	×
32	throw new IllegalArgumentException();	×
33	}
34	this.rowGrowSize = rowGrowSize;	×
35	}	×
36
37	public void setColumnGrowSize(int columnGrowSize) {
38	if (columnGrowSize < 1) {	×
39	throw new IllegalArgumentException();	×
40	}
41	this.columnGrowSize = columnGrowSize;	×
42	}	×
43
44	@Override
45	public E getCell(int row, int column) {
46	E cellValue = null;	1✔
47
48	if (table != null && row < table.length && column < table[row].length) {	1✔
49	cellValue = table[row][column];	1✔
50	}
51
52	if (cellValue == null) {	1✔
53	cellValue = defaultCellValue;	1✔
54	}
55
56	return cellValue;	1✔
57	}
58
59	@Override
60	public E setCell(int row, int column, E element) {
61	ensureCapacity(row, column);	1✔
62
63	E previousElement = table[row][column];	1✔
64	table[row][column] = element;	1✔
65	return previousElement;	1✔
66	}
67
68	private void ensureCapacity(int row, int column) {
69	if (row >= table.length) {	1✔
70	E[][] newTable = growRows(row);	1✔
71
72	for (int i = 0; i < table.length; i++) {	1✔
73	newTable[i] = table[i];	1✔
74	}
75
76	table = newTable;	1✔
77	}
78
79	if (column >= table[row].length) {	1✔
80	E[] newColumns = growColumns(row, column);	1✔
81	System.arraycopy(table[row], 0, newColumns, 0, table[row].length);	1✔
82	table[row] = newColumns;	1✔
83	}
84	}	1✔
85
86	protected E[] growColumns(int row, int column) {
87	int newSize = column + 1 + columnGrowSize;	1✔
88	if (newSize < 0) {	1✔
89	newSize = Integer.MAX_VALUE;	×
90	}
91	return (E[]) Array.newInstance(elementType, newSize);	1✔
92	}
93
94	protected E[][] growRows(int minRows) {
95	int newSize = minRows + 1 + rowGrowSize;	1✔
96	if (newSize < 0) {	1✔
97	newSize = Integer.MAX_VALUE;	×
98	}
99	return (E[][]) Array.newInstance(elementType, newSize, 0);	1✔
100	}
101
102	}

link-intersystems / lis-commons / #243

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous