2015-06-20 10:54:49 +00:00
|
|
|
/* ========================================================================
|
|
|
|
* PlantUML : a free UML diagram generator
|
|
|
|
* ========================================================================
|
|
|
|
*
|
2019-01-16 18:34:41 +00:00
|
|
|
* (C) Copyright 2009-2020, Arnaud Roques
|
2015-06-20 10:54:49 +00:00
|
|
|
*
|
2016-03-06 16:47:34 +00:00
|
|
|
* Project Info: http://plantuml.com
|
2015-06-20 10:54:49 +00:00
|
|
|
*
|
2017-03-15 19:13:31 +00:00
|
|
|
* If you like this project or if you find it useful, you can support us at:
|
|
|
|
*
|
|
|
|
* http://plantuml.com/patreon (only 1$ per month!)
|
|
|
|
* http://plantuml.com/paypal
|
|
|
|
*
|
2015-06-20 10:54:49 +00:00
|
|
|
* This file is part of PlantUML.
|
|
|
|
*
|
|
|
|
* PlantUML is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* PlantUML distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
|
|
|
* License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
* License along with this library; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
|
|
* USA.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Original Author: Arnaud Roques
|
|
|
|
*
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
package net.sourceforge.plantuml.command;
|
|
|
|
|
2019-01-16 18:34:41 +00:00
|
|
|
import java.io.BufferedReader;
|
|
|
|
import java.io.IOException;
|
2019-04-21 20:40:01 +00:00
|
|
|
import java.io.InputStream;
|
|
|
|
import java.io.InputStreamReader;
|
2015-06-20 10:54:49 +00:00
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.Iterator;
|
|
|
|
import java.util.List;
|
|
|
|
|
2017-04-26 17:48:37 +00:00
|
|
|
import net.sourceforge.plantuml.BackSlash;
|
2019-03-29 22:14:07 +00:00
|
|
|
import net.sourceforge.plantuml.LineLocation;
|
|
|
|
import net.sourceforge.plantuml.StringLocated;
|
2015-06-20 10:54:49 +00:00
|
|
|
import net.sourceforge.plantuml.cucadiagram.Display;
|
2020-05-30 15:20:23 +00:00
|
|
|
import net.sourceforge.plantuml.security.SFile;
|
2021-02-02 10:12:15 +00:00
|
|
|
import net.sourceforge.plantuml.ugraphic.color.NoSuchColorException;
|
2015-06-20 10:54:49 +00:00
|
|
|
|
2019-03-29 22:14:07 +00:00
|
|
|
public class BlocLines implements Iterable<StringLocated> {
|
|
|
|
|
|
|
|
private List<StringLocated> lines;
|
|
|
|
|
2015-09-06 17:28:59 +00:00
|
|
|
@Override
|
|
|
|
public String toString() {
|
2020-05-07 14:12:08 +00:00
|
|
|
final StringBuilder sb = new StringBuilder();
|
|
|
|
for (StringLocated line : lines) {
|
|
|
|
sb.append("<<<");
|
|
|
|
sb.append(line);
|
|
|
|
sb.append(">>>");
|
|
|
|
}
|
|
|
|
return sb.toString();
|
2015-09-06 17:28:59 +00:00
|
|
|
}
|
2015-06-20 10:54:49 +00:00
|
|
|
|
2020-05-30 15:20:23 +00:00
|
|
|
public static BlocLines load(SFile f, LineLocation location) throws IOException {
|
|
|
|
final BufferedReader br = f.openBufferedReader();
|
|
|
|
if (br == null) {
|
|
|
|
return null;
|
|
|
|
}
|
2019-04-21 20:40:01 +00:00
|
|
|
return loadInternal(br, location);
|
|
|
|
}
|
|
|
|
|
|
|
|
public static BlocLines load(InputStream is, LineLocation location) throws IOException {
|
|
|
|
final BufferedReader br = new BufferedReader(new InputStreamReader(is));
|
|
|
|
return loadInternal(br, location);
|
|
|
|
}
|
|
|
|
|
2021-03-04 18:11:16 +00:00
|
|
|
public static BlocLines from(List<StringLocated> lines) {
|
|
|
|
return new BlocLines(lines);
|
|
|
|
}
|
|
|
|
|
2019-04-21 20:40:01 +00:00
|
|
|
private static BlocLines loadInternal(final BufferedReader br, LineLocation location) throws IOException {
|
|
|
|
final List<StringLocated> result = new ArrayList<StringLocated>();
|
2019-01-16 18:34:41 +00:00
|
|
|
String s;
|
2021-03-04 18:11:16 +00:00
|
|
|
try {
|
|
|
|
while ((s = br.readLine()) != null) {
|
|
|
|
result.add(new StringLocated(s, location));
|
|
|
|
}
|
|
|
|
} finally {
|
|
|
|
br.close();
|
2019-01-16 18:34:41 +00:00
|
|
|
}
|
|
|
|
return new BlocLines(result);
|
|
|
|
}
|
|
|
|
|
2019-03-29 22:14:07 +00:00
|
|
|
private BlocLines(List<StringLocated> lines) {
|
|
|
|
this.lines = Collections.unmodifiableList(lines);
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
2015-08-05 20:17:01 +00:00
|
|
|
|
2021-02-02 10:12:15 +00:00
|
|
|
public Display toDisplay() throws NoSuchColorException {
|
2019-03-29 22:14:07 +00:00
|
|
|
return Display.createFoo(lines);
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 14:12:08 +00:00
|
|
|
public static BlocLines single(StringLocated single) {
|
2019-03-29 22:14:07 +00:00
|
|
|
final List<StringLocated> result = new ArrayList<StringLocated>();
|
|
|
|
result.add(single);
|
|
|
|
return new BlocLines(result);
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
2015-08-05 20:17:01 +00:00
|
|
|
|
2019-03-29 22:14:07 +00:00
|
|
|
public static BlocLines singleString(String single) {
|
|
|
|
final List<StringLocated> result = new ArrayList<StringLocated>();
|
|
|
|
result.add(new StringLocated(single, null));
|
|
|
|
return new BlocLines(result);
|
|
|
|
}
|
|
|
|
|
2020-02-18 21:24:31 +00:00
|
|
|
public static BlocLines fromArray(String[] array) {
|
|
|
|
final List<StringLocated> result = new ArrayList<StringLocated>();
|
|
|
|
for (String single : array) {
|
|
|
|
result.add(new StringLocated(single, null));
|
|
|
|
}
|
|
|
|
return new BlocLines(result);
|
|
|
|
}
|
|
|
|
|
2019-03-29 22:14:07 +00:00
|
|
|
public static BlocLines getWithNewlines(String s) {
|
|
|
|
final List<StringLocated> result = new ArrayList<StringLocated>();
|
|
|
|
for (String cs : BackSlash.getWithNewlines(s)) {
|
|
|
|
result.add(new StringLocated(cs, null));
|
|
|
|
}
|
|
|
|
return new BlocLines(result);
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public BlocLines() {
|
2019-03-29 22:14:07 +00:00
|
|
|
this(new ArrayList<StringLocated>());
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 14:12:08 +00:00
|
|
|
public BlocLines add(StringLocated s) {
|
2019-03-29 22:14:07 +00:00
|
|
|
final List<StringLocated> copy = new ArrayList<StringLocated>(lines);
|
2015-06-20 10:54:49 +00:00
|
|
|
copy.add(s);
|
|
|
|
return new BlocLines(copy);
|
|
|
|
}
|
|
|
|
|
2019-03-29 22:14:07 +00:00
|
|
|
public BlocLines addString(String s) {
|
|
|
|
final List<StringLocated> copy = new ArrayList<StringLocated>(lines);
|
|
|
|
copy.add(new StringLocated(s, null));
|
|
|
|
return new BlocLines(copy);
|
|
|
|
}
|
|
|
|
|
|
|
|
public List<String> getLinesAsStringForSprite() {
|
|
|
|
final List<String> result = new ArrayList<String>();
|
|
|
|
for (StringLocated s : lines) {
|
|
|
|
result.add(s.getString());
|
|
|
|
}
|
|
|
|
return result;
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public int size() {
|
|
|
|
return lines.size();
|
|
|
|
}
|
|
|
|
|
2020-05-07 14:12:08 +00:00
|
|
|
public StringLocated getAt(int i) {
|
2015-06-20 10:54:49 +00:00
|
|
|
return lines.get(i);
|
|
|
|
}
|
|
|
|
|
2020-05-07 14:12:08 +00:00
|
|
|
public StringLocated getFirst() {
|
2018-06-12 20:50:45 +00:00
|
|
|
if (lines.size() == 0) {
|
2017-12-11 21:02:10 +00:00
|
|
|
return null;
|
|
|
|
}
|
2015-06-20 10:54:49 +00:00
|
|
|
return lines.get(0);
|
|
|
|
}
|
|
|
|
|
2020-05-07 14:12:08 +00:00
|
|
|
public StringLocated getLast() {
|
2015-06-20 10:54:49 +00:00
|
|
|
return lines.get(lines.size() - 1);
|
|
|
|
}
|
|
|
|
|
2020-05-07 14:12:08 +00:00
|
|
|
public BlocLines cleanList(MultilinesStrategy strategy) {
|
2019-03-29 22:14:07 +00:00
|
|
|
final List<StringLocated> copy = new ArrayList<StringLocated>(lines);
|
2015-06-20 10:54:49 +00:00
|
|
|
strategy.cleanList(copy);
|
|
|
|
return new BlocLines(copy);
|
|
|
|
}
|
|
|
|
|
2020-05-07 14:12:08 +00:00
|
|
|
public BlocLines trim() {
|
2019-03-29 22:14:07 +00:00
|
|
|
final List<StringLocated> copy = new ArrayList<StringLocated>(lines);
|
2015-06-20 10:54:49 +00:00
|
|
|
for (int i = 0; i < copy.size(); i++) {
|
2019-03-29 22:14:07 +00:00
|
|
|
final StringLocated s = copy.get(i);
|
2020-05-07 14:12:08 +00:00
|
|
|
copy.set(i, s.getTrimmed());
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
2020-05-07 14:12:08 +00:00
|
|
|
return new BlocLines(copy);
|
|
|
|
}
|
|
|
|
|
|
|
|
public BlocLines removeEmptyLines() {
|
|
|
|
final List<StringLocated> copy = new ArrayList<StringLocated>(lines);
|
|
|
|
for (final Iterator<StringLocated> it = copy.iterator(); it.hasNext();) {
|
|
|
|
if (it.next().getString().length() == 0) {
|
|
|
|
it.remove();
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return new BlocLines(copy);
|
|
|
|
}
|
|
|
|
|
2020-05-07 14:12:08 +00:00
|
|
|
// public BlocLines trimRight() {
|
|
|
|
// final List<StringLocated> copy = new ArrayList<StringLocated>(lines);
|
|
|
|
// for (int i = 0; i < copy.size(); i++) {
|
|
|
|
// final StringLocated s = copy.get(i);
|
|
|
|
// copy.set(i, s.getTrimmedRight());
|
|
|
|
// }
|
|
|
|
// return new BlocLines(copy);
|
|
|
|
// }
|
|
|
|
|
2015-06-20 10:54:49 +00:00
|
|
|
public BlocLines removeEmptyColumns() {
|
|
|
|
if (firstColumnRemovable(lines) == false) {
|
|
|
|
return this;
|
|
|
|
}
|
2019-03-29 22:14:07 +00:00
|
|
|
final List<StringLocated> copy = new ArrayList<StringLocated>(lines);
|
2015-06-20 10:54:49 +00:00
|
|
|
do {
|
|
|
|
for (int i = 0; i < copy.size(); i++) {
|
2019-03-29 22:14:07 +00:00
|
|
|
final StringLocated s = copy.get(i);
|
|
|
|
if (s.getString().length() > 0) {
|
2020-03-03 22:29:34 +00:00
|
|
|
copy.set(i, s.substring(1, s.getString().length()));
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (firstColumnRemovable(copy));
|
|
|
|
return new BlocLines(copy);
|
|
|
|
}
|
|
|
|
|
2019-03-29 22:14:07 +00:00
|
|
|
private static boolean firstColumnRemovable(List<StringLocated> data) {
|
2015-06-20 10:54:49 +00:00
|
|
|
boolean allEmpty = true;
|
2019-03-29 22:14:07 +00:00
|
|
|
for (StringLocated s : data) {
|
|
|
|
if (s.getString().length() == 0) {
|
2015-06-20 10:54:49 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
allEmpty = false;
|
2019-03-29 22:14:07 +00:00
|
|
|
final char c = s.getString().charAt(0);
|
2015-06-20 10:54:49 +00:00
|
|
|
if (c != ' ' && c != '\t') {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return allEmpty == false;
|
|
|
|
}
|
|
|
|
|
|
|
|
public char getLastChar() {
|
2019-03-29 22:14:07 +00:00
|
|
|
final StringLocated s = lines.get(lines.size() - 1);
|
|
|
|
return s.getString().charAt(s.getString().length() - 1);
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 14:12:08 +00:00
|
|
|
public BlocLines removeStartingAndEnding(String data, int removeAtEnd) {
|
2015-06-20 10:54:49 +00:00
|
|
|
if (lines.size() == 0) {
|
|
|
|
return this;
|
|
|
|
}
|
2019-03-29 22:14:07 +00:00
|
|
|
final List<StringLocated> copy = new ArrayList<StringLocated>(lines);
|
|
|
|
copy.set(0, new StringLocated(data, null));
|
2015-06-20 10:54:49 +00:00
|
|
|
final int n = copy.size() - 1;
|
2019-03-29 22:14:07 +00:00
|
|
|
final StringLocated s = copy.get(n);
|
2020-05-07 14:12:08 +00:00
|
|
|
copy.set(n, s.substring(0, s.getString().length() - removeAtEnd));
|
|
|
|
return new BlocLines(copy);
|
|
|
|
}
|
|
|
|
|
|
|
|
public BlocLines overrideLastLine(String last) {
|
|
|
|
if (lines.size() == 0) {
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
final List<StringLocated> copy = new ArrayList<StringLocated>(lines);
|
|
|
|
final int n = copy.size() - 1;
|
|
|
|
final StringLocated currentLast = copy.get(n);
|
|
|
|
copy.set(n, new StringLocated(last, currentLast.getLocation()));
|
2015-06-20 10:54:49 +00:00
|
|
|
return new BlocLines(copy);
|
|
|
|
}
|
|
|
|
|
2017-06-05 11:27:21 +00:00
|
|
|
public BlocLines toSingleLineWithHiddenNewLine() {
|
2015-06-20 10:54:49 +00:00
|
|
|
final StringBuilder sb = new StringBuilder();
|
2019-03-29 22:14:07 +00:00
|
|
|
for (StringLocated line : lines) {
|
|
|
|
sb.append(line.getString());
|
2017-04-26 17:48:37 +00:00
|
|
|
sb.append(BackSlash.hiddenNewLine());
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
2019-03-29 22:14:07 +00:00
|
|
|
return singleString(sb.substring(0, sb.length() - 1).toString());
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public BlocLines trimSmart(int referenceLine) {
|
|
|
|
if (lines.size() <= referenceLine) {
|
|
|
|
return this;
|
|
|
|
}
|
2019-03-29 22:14:07 +00:00
|
|
|
final List<StringLocated> copy = new ArrayList<StringLocated>(lines);
|
|
|
|
final int nbStartingSpace = nbStartingSpace(copy.get(referenceLine).getString());
|
2015-06-20 10:54:49 +00:00
|
|
|
for (int i = referenceLine; i < copy.size(); i++) {
|
2019-03-29 22:14:07 +00:00
|
|
|
final StringLocated s = copy.get(i);
|
2015-06-20 10:54:49 +00:00
|
|
|
copy.set(i, removeStartingSpaces(s, nbStartingSpace));
|
|
|
|
}
|
|
|
|
return new BlocLines(copy);
|
|
|
|
}
|
|
|
|
|
|
|
|
private static int nbStartingSpace(CharSequence s) {
|
|
|
|
int nb = 0;
|
|
|
|
while (nb < s.length() && isSpaceOrTab(s.charAt(nb))) {
|
|
|
|
nb++;
|
|
|
|
}
|
|
|
|
return nb;
|
|
|
|
}
|
|
|
|
|
|
|
|
private static boolean isSpaceOrTab(char c) {
|
|
|
|
return c == ' ' || c == '\t';
|
|
|
|
}
|
|
|
|
|
2019-03-29 22:14:07 +00:00
|
|
|
private static StringLocated removeStartingSpaces(StringLocated arg, int nbStartingSpace) {
|
|
|
|
if (arg.getString().length() == 0) {
|
2015-06-20 10:54:49 +00:00
|
|
|
return arg;
|
|
|
|
}
|
|
|
|
int i = 0;
|
2019-03-29 22:14:07 +00:00
|
|
|
while (i < nbStartingSpace && i < arg.getString().length() && isSpaceOrTab(arg.getString().charAt(i))) {
|
2015-06-20 10:54:49 +00:00
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if (i == 0) {
|
|
|
|
return arg;
|
|
|
|
}
|
2020-03-03 22:29:34 +00:00
|
|
|
return arg.substring(i, arg.getString().length());
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|
|
|
|
|
2019-01-16 18:34:41 +00:00
|
|
|
public BlocLines subExtract(int margeStart, int margeEnd) {
|
2019-03-29 22:14:07 +00:00
|
|
|
List<StringLocated> copy = new ArrayList<StringLocated>(lines);
|
2019-01-16 18:34:41 +00:00
|
|
|
copy = copy.subList(margeStart, copy.size() - margeEnd);
|
2015-06-20 10:54:49 +00:00
|
|
|
return new BlocLines(copy);
|
|
|
|
}
|
|
|
|
|
2019-01-16 18:34:41 +00:00
|
|
|
public BlocLines subList(int start, int end) {
|
|
|
|
return new BlocLines(lines.subList(start, end));
|
|
|
|
}
|
|
|
|
|
2019-03-29 22:14:07 +00:00
|
|
|
public Iterator<StringLocated> iterator() {
|
2015-06-20 10:54:49 +00:00
|
|
|
return lines.iterator();
|
|
|
|
}
|
|
|
|
|
2018-06-12 20:50:45 +00:00
|
|
|
public BlocLines eventuallyMoveBracket() {
|
|
|
|
if (size() < 2) {
|
|
|
|
return this;
|
|
|
|
}
|
2020-05-07 14:12:08 +00:00
|
|
|
final String first = getFirst().getTrimmed().getString();
|
|
|
|
final String second = getAt(1).getTrimmed().getString();
|
2018-06-12 20:50:45 +00:00
|
|
|
if (first.endsWith("{") == false && second.equals("{")) {
|
2020-05-07 14:12:08 +00:00
|
|
|
final StringLocated vline = getFirst().append(" {");
|
2019-03-29 22:14:07 +00:00
|
|
|
final List<StringLocated> result = new ArrayList<StringLocated>();
|
2019-09-14 18:12:04 +00:00
|
|
|
result.add(vline);
|
2018-06-12 20:50:45 +00:00
|
|
|
result.addAll(this.lines.subList(2, this.lines.size()));
|
|
|
|
return new BlocLines(result);
|
|
|
|
}
|
2017-12-11 21:02:10 +00:00
|
|
|
return this;
|
2015-11-01 18:37:20 +00:00
|
|
|
}
|
2019-01-16 18:34:41 +00:00
|
|
|
|
2019-09-14 18:12:04 +00:00
|
|
|
public BlocLines eventuallyMoveAllEmptyBracket() {
|
|
|
|
final List<StringLocated> result = new ArrayList<StringLocated>();
|
|
|
|
for (StringLocated line : lines) {
|
|
|
|
if (line.getTrimmed().toString().equals("{")) {
|
|
|
|
if (result.size() > 0) {
|
|
|
|
final int pos = result.size() - 1;
|
|
|
|
StringLocated last = result.get(pos);
|
|
|
|
result.set(pos, last.append(" {"));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
result.add(line);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return new BlocLines(result);
|
|
|
|
}
|
|
|
|
|
2015-06-20 10:54:49 +00:00
|
|
|
}
|