| Total Complexity | 16 |
| Total Lines | 175 |
| Duplicated Lines | 5.14 % |
| Changes | 1 | ||
| Bugs | 0 | Features | 0 |
Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
| 1 | /* |
||
| 33 | final public class DefaultMapDataSerializer implements MapDataSerializer { |
||
| 34 | final static private int CELL_DATA_LENGTH = 10; |
||
| 35 | |||
| 36 | private static class ByteArrayCell implements CellData { |
||
| 37 | final private byte[] data; |
||
| 38 | |||
| 39 | public ByteArrayCell(byte[] data) { |
||
| 40 | this.data = data; |
||
| 41 | } |
||
| 42 | |||
| 43 | @Override |
||
| 44 | public boolean lineOfSight() { |
||
| 45 | return (data[0] & 1) == 1; |
||
| 46 | } |
||
| 47 | |||
| 48 | @Override |
||
| 49 | public CellMovement movement() { |
||
| 50 | return CellMovement.byValue((data[2] & 56) >> 3); |
||
| 51 | } |
||
| 52 | |||
| 53 | @Override |
||
| 54 | public boolean active() { |
||
| 55 | return (data[0] & 32) >> 5 == 1; |
||
| 56 | } |
||
| 57 | |||
| 58 | @Override |
||
| 59 | public GroundCellData ground() { |
||
| 60 | return new GroundCellData() { |
||
| 61 | @Override |
||
| 62 | public int level() { |
||
| 63 | return data[1] & 15; |
||
| 64 | } |
||
| 65 | |||
| 66 | @Override |
||
| 67 | public int slope() { |
||
| 68 | return (data[4] & 60) >> 2; |
||
| 69 | } |
||
| 70 | |||
| 71 | View Code Duplication | @Override |
|
|
1 ignored issue
–
show
|
|||
| 72 | public int number() { |
||
| 73 | return ((data[0] & 24) << 6) + ((data[2] & 7) << 6) + data[3]; |
||
| 74 | } |
||
| 75 | |||
| 76 | @Override |
||
| 77 | public int rotation() { |
||
| 78 | return (data[1] & 48) >> 4; |
||
| 79 | } |
||
| 80 | |||
| 81 | @Override |
||
| 82 | public boolean flip() { |
||
| 83 | return (data[4] & 2) >> 1 == 1; |
||
| 84 | } |
||
| 85 | }; |
||
| 86 | } |
||
| 87 | |||
| 88 | @Override |
||
| 89 | public CellLayerData layer1() { |
||
| 90 | return new CellLayerData() { |
||
| 91 | View Code Duplication | @Override |
|
|
1 ignored issue
–
show
|
|||
| 92 | public int number() { |
||
| 93 | return ((data[0] & 4) << 11) + ((data[4] & 1) << 12) + (data[5] << 6) + data[6]; |
||
| 94 | } |
||
| 95 | |||
| 96 | @Override |
||
| 97 | public int rotation() { |
||
| 98 | return (data[7] & 48) >> 4; |
||
| 99 | } |
||
| 100 | |||
| 101 | @Override |
||
| 102 | public boolean flip() { |
||
| 103 | return (data[7] & 8) >> 3 == 1; |
||
| 104 | } |
||
| 105 | }; |
||
| 106 | } |
||
| 107 | |||
| 108 | @Override |
||
| 109 | public InteractiveObjectData layer2() { |
||
| 110 | return new InteractiveObjectData() { |
||
| 111 | @Override |
||
| 112 | public boolean interactive() { |
||
| 113 | return (data[7] & 2) >> 1 == 1; |
||
| 114 | } |
||
| 115 | |||
| 116 | View Code Duplication | @Override |
|
|
1 ignored issue
–
show
|
|||
| 117 | public int number() { |
||
| 118 | return ((data[0] & 2) << 12) + ((data[7] & 1) << 12) + (data[8] << 6) + data[9]; |
||
| 119 | } |
||
| 120 | |||
| 121 | @Override |
||
| 122 | public boolean flip() { |
||
| 123 | return (data[7] & 4) >> 2 == 1; |
||
| 124 | } |
||
| 125 | }; |
||
| 126 | } |
||
| 127 | } |
||
| 128 | |||
| 129 | private Map<String, ByteArrayCell> cache; |
||
| 130 | |||
| 131 | @Override |
||
| 132 | public CellData[] deserialize(String mapData) { |
||
| 133 | if (mapData.length() % CELL_DATA_LENGTH != 0) { |
||
| 134 | throw new IllegalArgumentException("Invalid map data"); |
||
| 135 | } |
||
| 136 | |||
| 137 | final int size = mapData.length() / CELL_DATA_LENGTH; |
||
| 138 | final CellData[] cells = new CellData[size]; |
||
| 139 | |||
| 140 | for (int i = 0; i < size; ++i) { |
||
| 141 | cells[i] = deserializeCell(mapData.substring(i * CELL_DATA_LENGTH, (i + 1) * CELL_DATA_LENGTH)); |
||
| 142 | } |
||
| 143 | |||
| 144 | return cells; |
||
| 145 | } |
||
| 146 | |||
| 147 | @Override |
||
| 148 | public String serialize(CellData[] cells) { |
||
| 149 | StringBuilder sb = new StringBuilder(cells.length * CELL_DATA_LENGTH); |
||
| 150 | |||
| 151 | for (CellData cell : cells) { |
||
| 152 | sb.append(serializeCell(cell)); |
||
| 153 | } |
||
| 154 | |||
| 155 | return sb.toString(); |
||
| 156 | } |
||
| 157 | |||
| 158 | /** |
||
| 159 | * Enable the cell data cache |
||
| 160 | * Once enable, deserialize two same cell data will return the same cell instance |
||
| 161 | */ |
||
| 162 | public void enableCache() { |
||
| 163 | cache = new ConcurrentHashMap<>(); |
||
| 164 | } |
||
| 165 | |||
| 166 | /** |
||
| 167 | * Disable cell data cache |
||
| 168 | */ |
||
| 169 | public void disableCache() { |
||
| 170 | cache = null; |
||
| 171 | } |
||
| 172 | |||
| 173 | private CellData deserializeCell(String cellData) { |
||
| 174 | if (cache == null) { |
||
| 175 | return new ByteArrayCell(Base64.toBytes(cellData)); |
||
| 176 | } |
||
| 177 | |||
| 178 | return cache.computeIfAbsent(cellData, data -> new ByteArrayCell(Base64.toBytes(data))); |
||
| 179 | } |
||
| 180 | |||
| 181 | private String serializeCell(CellData cell) { |
||
| 182 | final byte[] data = new byte[CELL_DATA_LENGTH]; |
||
| 183 | |||
| 184 | data[0] = (byte) ((cell.active() ? (1) : (0)) << 5); |
||
| 185 | data[0] = (byte) (data[0] | (cell.lineOfSight() ? (1) : (0))); |
||
| 186 | data[0] = (byte) (data[0] | (cell.ground().number() & 1536) >> 6); |
||
|
1 ignored issue
–
show
|
|||
| 187 | data[0] = (byte) (data[0] | (cell.layer1().number() & 8192) >> 11); |
||
|
1 ignored issue
–
show
|
|||
| 188 | data[0] = (byte) (data[0] | (cell.layer2().number() & 8192) >> 12); |
||
|
1 ignored issue
–
show
|
|||
| 189 | data[1] = (byte) ((cell.ground().rotation() & 3) << 4); |
||
| 190 | data[1] = (byte) (data[1] | cell.ground().level() & 15); |
||
| 191 | data[2] = (byte) ((cell.movement().ordinal() & 7) << 3); |
||
| 192 | data[2] = (byte) (data[2] | cell.ground().number() >> 6 & 7); |
||
| 193 | data[3] = (byte) (cell.ground().number() & 63); |
||
| 194 | data[4] = (byte) ((cell.ground().slope() & 15) << 2); |
||
| 195 | data[4] = (byte) (data[4] | (cell.ground().flip() ? (1) : (0)) << 1); |
||
|
1 ignored issue
–
show
|
|||
| 196 | data[4] = (byte) (data[4] | cell.layer1().number() >> 12 & 1); |
||
| 197 | data[5] = (byte) (cell.layer1().number() >> 6 & 63); |
||
| 198 | data[6] = (byte) (cell.layer1().number() & 63); |
||
| 199 | data[7] = (byte) ((cell.layer1().rotation() & 3) << 4); |
||
| 200 | data[7] = (byte) (data[7] | (cell.layer1().flip() ? (1) : (0)) << 3); |
||
|
1 ignored issue
–
show
|
|||
| 201 | data[7] = (byte) (data[7] | (cell.layer2().flip() ? (1) : (0)) << 2); |
||
|
1 ignored issue
–
show
|
|||
| 202 | data[7] = (byte) (data[7] | (cell.layer2().interactive() ? (1) : (0)) << 1); |
||
|
1 ignored issue
–
show
|
|||
| 203 | data[7] = (byte) (data[7] | cell.layer2().number() >> 12 & 1); |
||
| 204 | data[8] = (byte) (cell.layer2().number() >> 6 & 63); |
||
| 205 | data[9] = (byte) (cell.layer2().number() & 63); |
||
| 206 | |||
| 207 | return Base64.encode(data); |
||
| 208 | } |
||
| 210 |