package foundation.variant.expression;
|
|
import java.util.ArrayList;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Set;
|
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
|
import foundation.util.Util;
|
import foundation.variant.provider.DataEvent;
|
import foundation.variant.provider.IVariantsConsumer;
|
import foundation.variant.provider.IVariantsProvider;
|
|
public class VariantExpression implements Iterable<VariantSegment>, IVariantParseListener, IExpression, IVariantsConsumer {
|
|
protected static Logger logger;
|
protected List<Segment> segments;
|
protected VariantList variantList;
|
protected VariantParser parser;
|
|
static {
|
logger = LogManager.getLogger(VariantExpression.class);
|
}
|
|
private VariantExpression(int size) throws Exception {
|
if (size <= 0) {
|
size = 8;
|
}
|
|
segments = new ArrayList<Segment>(size);
|
variantList = new VariantList();
|
}
|
|
public VariantExpression() {
|
segments = new ArrayList<Segment>(8);
|
variantList = new VariantList();
|
parser = new VariantParser(this);
|
}
|
|
public VariantExpression(String String) throws Exception {
|
this(String, 0);
|
}
|
|
public VariantExpression(String String, int size) throws Exception {
|
this(size);
|
|
VariantParser parser = new VariantParser(this);
|
parser.parse(String);
|
}
|
|
public VariantExpression newInstance() throws Exception {
|
int size = segments.size();
|
VariantExpression instance = new VariantExpression(size);
|
|
Segment segment;
|
VariantSegment param;
|
|
for (int i = 0; i < size; i++) {
|
segment = segments.get(i);
|
|
if (segment instanceof VariantSegment) {
|
param = (VariantSegment) segment;
|
String name = param.getName();
|
|
if (instance.variantList.contains(param.getName())) {
|
instance.segments.add(instance.variantList.get(name));
|
}
|
else {
|
segment = segment.newInstance();
|
instance.segments.add(segment);
|
instance.variantList.add(name, (VariantSegment) segment);
|
}
|
}
|
else {
|
segment = segment.newInstance();
|
instance.segments.add(segment);
|
}
|
}
|
|
return instance;
|
}
|
|
public void parseOneLine(String value) throws Exception {
|
parser.parse(value);
|
}
|
|
public String tryGetString() throws Exception {
|
for (VariantSegment variant : variantList) {
|
if (variant.isEmpty()) {
|
throw new Exception("empty variant param: " + variant.getName());
|
}
|
}
|
|
return getString();
|
}
|
|
public String getString() {
|
StringBuilder result = new StringBuilder();
|
|
int n = segments.size();
|
Segment segment;
|
String value;
|
|
for (int i = 0; i < n; i++) {
|
segment = segments.get(i);
|
value = segment.getValue();
|
|
result.append(value);
|
}
|
|
return result.toString();
|
}
|
|
@Override
|
public void onSegment(String value) {
|
if (Util.isEmpty(value)) {
|
return;
|
}
|
|
Segment segment = new StringSegment(value);
|
segments.add(segment);
|
}
|
|
@Override
|
public void addVariant(String name) throws Exception {
|
if (Util.isEmpty(name)) {
|
return;
|
}
|
|
if (variantList.contains(name)) {
|
VariantSegment segment = variantList.get(name);
|
segments.add(segment);
|
}
|
else {
|
VariantSegment segment = new VariantSegment(name);
|
segments.add(segment);
|
variantList.add(name, segment);
|
}
|
}
|
|
public VariantSegment getVariant(String name) {
|
return variantList.get(name);
|
}
|
|
public Iterator<VariantSegment> iterator() {
|
return variantList.getItemList().iterator();
|
}
|
|
@Override
|
public VariantList getVariantList() {
|
return variantList;
|
}
|
|
public boolean isVariantListEmpty() {
|
return variantList.isEmpty();
|
}
|
|
public void clearVariantValues() {
|
for (VariantSegment variant: variantList) {
|
variant.clearValue();
|
}
|
}
|
|
public boolean containsVariant(String name) {
|
return variantList.contains(name);
|
}
|
|
@Override
|
public boolean isVariantNull(String name) {
|
VariantSegment segment = getVariant(name);
|
return segment.isEmpty();
|
}
|
|
public List<Segment> getSegments() {
|
return segments;
|
}
|
|
@Override
|
public Set<String> getVariantNames() {
|
return variantList.getKeySet();
|
}
|
|
@Override
|
public void setVariants(DataEvent dataEvent, IVariantsProvider... providers) throws Exception {
|
for (VariantSegment param: variantList) {
|
String name = param.getName();
|
|
for (IVariantsProvider provider: providers) {
|
if (provider.containsVariant(name)) {
|
Object value = provider.getVariantValue(dataEvent, name);
|
param.setValue(String.valueOf(value));
|
}
|
}
|
}
|
}
|
|
@Override
|
public void setVariant(DataEvent dataEvent, String name, Object value) throws Exception {
|
VariantSegment param = variantList.get(name);
|
|
if (param == null) {
|
return;
|
}
|
|
param.setValue(String.valueOf(value));
|
}
|
|
public void clear() {
|
segments.clear();
|
variantList.clear();
|
}
|
|
public void setFlag_Variant(char value) {
|
parser.setFlag_Variant(value);
|
}
|
|
public void setFlag_LeftQuote(char value) {
|
parser.setFlag_LeftQuote(value);
|
}
|
|
public void setFlag_RightQuote(char value) {
|
parser.setFlag_RightQuote(value);
|
}
|
|
@Override
|
public String toString() {
|
return getString();
|
}
|
|
}
|
