// the linkedId string used to match all linkedIds seen so far
protected static final String MATCHALLLINKEDIDS = "*";
+ // the linkedId string used to match all of the last --open'ed linkedIds
+ protected static final String MATCHOPENEDLINKEDIDS = "open*";
+
// the counter added to the default linked id prefix
private int defaultLinkedIdCounter = 0;
// or ALL linkedIds
private boolean allLinkedIds = false;
+ // flag to say whether the default linkedId is the current default linked id
+ // or OPENED linkedIds
+ private boolean openedLinkedIds = false;
+
protected static final Map<String, Arg> argMap;
protected Map<String, ArgValuesMap> linkedArgs = new HashMap<>();
protected List<String> linkedOrder = new ArrayList<>();
+ protected List<String> storedLinkedIds = new ArrayList<>();
+
protected List<Arg> argList = new ArrayList<>();
private static final char ARGFILECOMMENT = '#';
else if (a == Arg.ALL)
{
allLinkedIds = !negated;
+ openedLinkedIds = false;
+ }
+ else if (a == Arg.OPENED)
+ {
+ openedLinkedIds = !negated;
+ allLinkedIds = false;
+ }
+
+ if (a.hasOption(Opt.STORED))
+ {
+ // reset the lastOpenedLinkedIds list
+ this.storedLinkedIds = new ArrayList<>();
}
// this is probably only Arg.NEW and Arg.OPEN
if (linkedId == null)
{
if (a.hasOption(Opt.OUTPUT) && a.hasOption(Opt.ALLOWALL)
- && val.startsWith(OUTPUTWILDCARD))
+ && val.startsWith(MATCHALLLINKEDIDS))
{
// --output=*.ext is shorthand for --all --output {basename}.ext
// (or --image=*.ext)
allLinkedIds = true;
+ openedLinkedIds = false;
linkedId = MATCHALLLINKEDIDS;
- String oldval = val;
- val = LINKEDIDBASENAME
- + val.substring(OUTPUTWILDCARD.length() - 1);
+ val = LINKEDIDDIRNAME + File.separator + LINKEDIDBASENAME
+ + val.substring(MATCHALLLINKEDIDS.length());
+ }
+ else if (a.hasOption(Opt.OUTPUT) && a.hasOption(Opt.ALLOWALL)
+ && val.startsWith(MATCHOPENEDLINKEDIDS))
+ {
+ // --output=open*.ext is shorthand for --opened --output
+ // {basename}.ext
+ // (or --image=open*.ext)
+ openedLinkedIds = true;
+ allLinkedIds = false;
+ linkedId = MATCHOPENEDLINKEDIDS;
+ val = LINKEDIDDIRNAME + File.separator + LINKEDIDBASENAME
+ + val.substring(MATCHOPENEDLINKEDIDS.length());
}
else if (allLinkedIds && a.hasOption(Opt.ALLOWALL))
{
linkedId = MATCHALLLINKEDIDS;
}
+ else if (openedLinkedIds && a.hasOption(Opt.ALLOWALL))
+ {
+ linkedId = MATCHOPENEDLINKEDIDS;
+ }
else
{
// use default linkedId for linked arguments
setBoolean(linkedId, avs, true, argIndex);
}
- // remove the '*' linkedId that should be empty if it was created
- if (MATCHALLLINKEDIDS.equals(linkedId)
+ // remove the '*' or 'open*' linkedId that should be empty if it was
+ // created
+ if ((MATCHALLLINKEDIDS.equals(linkedId)
&& linkedArgs.containsKey(linkedId))
+ || (MATCHOPENEDLINKEDIDS.equals(linkedId)
+ && linkedArgs.containsKey(linkedId)))
{
linkedArgs.remove(linkedId);
}
}
// the following methods look for the "*" linkedId and add the argvalue to all
- // linkedId ArgValues if it does
+ // linkedId ArgValues if it does.
+ // This version inserts the subvals sv into all created values
private void addValue(String linkedId, ArgValues avs, SubVals sv,
String v, int argIndex, boolean doSubs)
{
+ this.argValueOperation(Op.ADDVALUE, linkedId, avs, sv, v, false,
+ argIndex, doSubs);
+ }
+
+ private void NOTaddValue(String linkedId, ArgValues avs, SubVals sv,
+ String v, int argIndex, boolean doSubs)
+ {
Arg a = avs.arg();
- if (MATCHALLLINKEDIDS.equals(linkedId) && a.hasOption(Opt.ALLOWALL))
+
+ List<String> wildcardLinkedIds = null;
+ if (a.hasOption(Opt.ALLOWALL))
{
- for (String id : getLinkedIds())
+ switch (linkedId)
{
- if (id == null || MATCHALLLINKEDIDS.equals(id))
+ case MATCHALLLINKEDIDS:
+ wildcardLinkedIds = getLinkedIds();
+ break;
+ case MATCHOPENEDLINKEDIDS:
+ wildcardLinkedIds = this.storedLinkedIds;
+ break;
+ }
+ }
+
+ // if we're not a wildcard linkedId and the arg is marked to be stored, add
+ // to storedLinkedIds
+ if (linkedId != null && wildcardLinkedIds == null
+ && a.hasOption(Opt.STORED)
+ && !storedLinkedIds.contains(linkedId))
+ {
+ storedLinkedIds.add(linkedId);
+ }
+
+ // if we are a wildcard linkedId, apply the arg and value to all appropriate
+ // linkedIds
+ if (wildcardLinkedIds != null)
+ {
+ for (String id : wildcardLinkedIds)
+ {
+ // skip incorrectly stored wildcard ids!
+ if (id == null || MATCHALLLINKEDIDS.equals(id)
+ || MATCHOPENEDLINKEDIDS.equals(id))
continue;
ArgValuesMap avm = linkedArgs.get(id);
if (a.hasOption(Opt.REQUIREINPUT)
private void addValue(String linkedId, ArgValues avs, String v,
int argIndex, boolean doSubs)
{
+ this.argValueOperation(Op.ADDVALUE, linkedId, avs, null, v, false,
+ argIndex, doSubs);
+ }
+
+ // the following methods look for the "*" linkedId and add the argvalue to all
+ // linkedId ArgValues if it does.
+ private void NOTaddValue(String linkedId, ArgValues avs, String v,
+ int argIndex, boolean doSubs)
+ {
Arg a = avs.arg();
- if (MATCHALLLINKEDIDS.equals(linkedId) && a.hasOption(Opt.ALLOWALL))
+ if (linkedId != null && a.hasOption(Opt.STORED)
+ && !storedLinkedIds.contains(linkedId))
{
- for (String id : getLinkedIds())
+ storedLinkedIds.add(linkedId);
+ }
+
+ List<String> wildcardLinkedIds = null;
+ if (a.hasOption(Opt.ALLOWALL))
+ {
+ switch (linkedId)
{
- if (id == null || MATCHALLLINKEDIDS.equals(id))
+ case MATCHALLLINKEDIDS:
+ wildcardLinkedIds = getLinkedIds();
+ break;
+ case MATCHOPENEDLINKEDIDS:
+ wildcardLinkedIds = this.storedLinkedIds;
+ break;
+ }
+ }
+
+ // if we're not a wildcard linkedId and the arg is marked to be stored, add
+ // to storedLinkedIds
+ if (linkedId != null && wildcardLinkedIds == null
+ && a.hasOption(Opt.STORED)
+ && !storedLinkedIds.contains(linkedId))
+ {
+ storedLinkedIds.add(linkedId);
+ }
+
+ // if we are a wildcard linkedId, apply the arg and value to all appropriate
+ // linkedIds
+ if (wildcardLinkedIds != null)
+ {
+ for (String id : wildcardLinkedIds)
+ {
+ // skip incorrectly stored wildcard ids!
+ if (id == null || MATCHALLLINKEDIDS.equals(id)
+ || MATCHOPENEDLINKEDIDS.equals(id))
continue;
ArgValuesMap avm = linkedArgs.get(id);
// don't set an output if there isn't an input
private void setBoolean(String linkedId, ArgValues avs, boolean b,
int argIndex)
{
+ this.argValueOperation(Op.SETBOOLEAN, linkedId, avs, null, null, b,
+ argIndex, false);
+ }
+
+ private void NOTsetBoolean(String linkedId, ArgValues avs, boolean b,
+ int argIndex)
+ {
Arg a = avs.arg();
- if (MATCHALLLINKEDIDS.equals(linkedId) && a.hasOption(Opt.ALLOWALL))
+ if (linkedId != null && a.hasOption(Opt.STORED)
+ && !storedLinkedIds.contains(linkedId))
{
- for (String id : getLinkedIds())
+ storedLinkedIds.add(linkedId);
+ }
+
+ List<String> wildcardLinkedIds = null;
+ if (a.hasOption(Opt.ALLOWALL))
+ {
+ switch (linkedId)
+ {
+ case MATCHALLLINKEDIDS:
+ wildcardLinkedIds = getLinkedIds();
+ break;
+ case MATCHOPENEDLINKEDIDS:
+ wildcardLinkedIds = this.storedLinkedIds;
+ break;
+ }
+ }
+
+ // if we're not a wildcard linkedId and the arg is marked to be stored, add
+ // to storedLinkedIds
+ if (linkedId != null && wildcardLinkedIds == null
+ && a.hasOption(Opt.STORED)
+ && !storedLinkedIds.contains(linkedId))
+ {
+ storedLinkedIds.add(linkedId);
+ }
+
+ // if we are a wildcard linkedId, apply the arg and value to all appropriate
+ // linkedIds
+ if (wildcardLinkedIds != null)
+ {
+ for (String id : wildcardLinkedIds)
{
- if (id == null || MATCHALLLINKEDIDS.equals(id))
+ // skip incorrectly stored wildcard ids!
+ if (id == null || MATCHALLLINKEDIDS.equals(id)
+ || MATCHOPENEDLINKEDIDS.equals(id))
continue;
ArgValuesMap avm = linkedArgs.get(id);
if (a.hasOption(Opt.REQUIREINPUT)
private void setNegated(String linkedId, ArgValues avs, boolean b)
{
+ this.argValueOperation(Op.SETNEGATED, linkedId, avs, null, null, b, 0,
+ false);
+ }
+
+ private void NOTsetNegated(String linkedId, ArgValues avs, boolean b)
+ {
Arg a = avs.arg();
- if (MATCHALLLINKEDIDS.equals(linkedId) && a.hasOption(Opt.ALLOWALL))
+ if (linkedId != null && a.hasOption(Opt.STORED)
+ && !storedLinkedIds.contains(linkedId))
{
- for (String id : getLinkedIds())
+ storedLinkedIds.add(linkedId);
+ }
+
+ List<String> wildcardLinkedIds = null;
+ if (a.hasOption(Opt.ALLOWALL))
+ {
+ switch (linkedId)
{
- if (id == null || MATCHALLLINKEDIDS.equals(id))
+ case MATCHALLLINKEDIDS:
+ wildcardLinkedIds = getLinkedIds();
+ break;
+ case MATCHOPENEDLINKEDIDS:
+ wildcardLinkedIds = this.storedLinkedIds;
+ break;
+ }
+ }
+
+ // if we're not a wildcard linkedId and the arg is marked to be stored, add
+ // to storedLinkedIds
+ if (linkedId != null && wildcardLinkedIds == null
+ && a.hasOption(Opt.STORED)
+ && !storedLinkedIds.contains(linkedId))
+ {
+ storedLinkedIds.add(linkedId);
+ }
+
+ // if we are a wildcard linkedId, apply the arg and value to all appropriate
+ // linkedIds
+ if (wildcardLinkedIds != null)
+ {
+ for (String id : wildcardLinkedIds)
+ {
+ // skip incorrectly stored wildcard ids!
+ if (id == null || MATCHALLLINKEDIDS.equals(id)
+ || MATCHOPENEDLINKEDIDS.equals(id))
continue;
ArgValuesMap avm = linkedArgs.get(id);
if (a.hasOption(Opt.REQUIREINPUT)
private void incrementCount(String linkedId, ArgValues avs)
{
+ this.argValueOperation(Op.INCREMENTCOUNT, linkedId, avs, null, null,
+ false, 0, false);
+ }
+
+ private void NOTincrementCount(String linkedId, ArgValues avs)
+ {
Arg a = avs.arg();
- if (MATCHALLLINKEDIDS.equals(linkedId) && a.hasOption(Opt.ALLOWALL))
+
+ List<String> wildcardLinkedIds = null;
+ if (a.hasOption(Opt.ALLOWALL))
{
- for (String id : getLinkedIds())
+ switch (linkedId)
{
- if (id == null || MATCHALLLINKEDIDS.equals(id))
+ case MATCHALLLINKEDIDS:
+ wildcardLinkedIds = getLinkedIds();
+ break;
+ case MATCHOPENEDLINKEDIDS:
+ wildcardLinkedIds = this.storedLinkedIds;
+ break;
+ }
+ }
+
+ // if we're not a wildcard linkedId and the arg is marked to be stored, add
+ // to storedLinkedIds
+ if (linkedId != null && wildcardLinkedIds == null
+ && a.hasOption(Opt.STORED)
+ && !storedLinkedIds.contains(linkedId))
+ {
+ storedLinkedIds.add(linkedId);
+ }
+
+ // if we are a wildcard linkedId, apply the arg and value to all appropriate
+ // linkedIds
+ if (wildcardLinkedIds != null)
+ {
+ for (String id : wildcardLinkedIds)
+ {
+ // skip incorrectly stored wildcard ids!
+ if (id == null || MATCHALLLINKEDIDS.equals(id)
+ || MATCHOPENEDLINKEDIDS.equals(id))
continue;
ArgValuesMap avm = linkedArgs.get(id);
if (a.hasOption(Opt.REQUIREINPUT)
}
}
+ private enum Op
+ {
+ ADDVALUE, SETBOOLEAN, SETNEGATED, INCREMENTCOUNT
+ }
+
+ // The following operations look for the "*" and "open*" linkedIds and add the
+ // argvalue to all appropriate linkedId ArgValues if it does.
+ // If subvals are supplied, they are inserted into all new set values.
+ private void argValueOperation(Op op, String linkedId, ArgValues avs,
+ SubVals sv, String v, boolean b, int argIndex, boolean doSubs)
+ {
+ Arg a = avs.arg();
+
+ List<String> wildcardLinkedIds = null;
+ if (a.hasOption(Opt.ALLOWALL))
+ {
+ switch (linkedId)
+ {
+ case MATCHALLLINKEDIDS:
+ wildcardLinkedIds = getLinkedIds();
+ break;
+ case MATCHOPENEDLINKEDIDS:
+ wildcardLinkedIds = this.storedLinkedIds;
+ break;
+ }
+ }
+
+ // if we're not a wildcard linkedId and the arg is marked to be stored, add
+ // to storedLinkedIds
+ if (linkedId != null && wildcardLinkedIds == null
+ && a.hasOption(Opt.STORED)
+ && !storedLinkedIds.contains(linkedId))
+ {
+ storedLinkedIds.add(linkedId);
+ }
+
+ // if we are a wildcard linkedId, apply the arg and value to all appropriate
+ // linkedIds
+ if (wildcardLinkedIds != null)
+ {
+ for (String id : wildcardLinkedIds)
+ {
+ // skip incorrectly stored wildcard ids!
+ if (id == null || MATCHALLLINKEDIDS.equals(id)
+ || MATCHOPENEDLINKEDIDS.equals(id))
+ continue;
+ ArgValuesMap avm = linkedArgs.get(id);
+ // don't set an output if there isn't an input
+ if (a.hasOption(Opt.REQUIREINPUT)
+ && !avm.hasArgWithOption(Opt.INPUT))
+ continue;
+
+ ArgValues tavs = avm.getOrCreateArgValues(a);
+ switch (op)
+ {
+
+ case ADDVALUE:
+ String val = v;
+ if (sv != null)
+ {
+ if (doSubs)
+ {
+ val = makeSubstitutions(v, id);
+ sv = new SubVals(sv, val);
+ }
+ tavs.addValue(sv, val, argIndex);
+ }
+ else
+ {
+ if (doSubs)
+ {
+ val = makeSubstitutions(v, id);
+ }
+ tavs.addValue(val, argIndex);
+ }
+ finaliseStoringArgValue(id, tavs);
+ break;
+
+ case SETBOOLEAN:
+ tavs.setBoolean(b, argIndex);
+ finaliseStoringArgValue(id, tavs);
+ break;
+
+ case SETNEGATED:
+ tavs.setNegated(b);
+ break;
+
+ case INCREMENTCOUNT:
+ tavs.incrementCount();
+ break;
+
+ default:
+ break;
+
+ }
+
+ }
+ }
+ else // no wildcard linkedId -- do it simpler
+ {
+ switch (op)
+ {
+ case ADDVALUE:
+ String val = v;
+ if (sv != null)
+ {
+ if (doSubs)
+ {
+ val = makeSubstitutions(v, linkedId);
+ sv = new SubVals(sv, val);
+ }
+ avs.addValue(sv, val, argIndex);
+ }
+ else
+ {
+ if (doSubs)
+ {
+ val = makeSubstitutions(v, linkedId);
+ }
+ avs.addValue(val, argIndex);
+ }
+ finaliseStoringArgValue(linkedId, avs);
+ break;
+
+ case SETBOOLEAN:
+ avs.setBoolean(b, argIndex);
+ finaliseStoringArgValue(linkedId, avs);
+ break;
+
+ case SETNEGATED:
+ avs.setNegated(b);
+ break;
+
+ case INCREMENTCOUNT:
+ avs.incrementCount();
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+
private ArgValuesMap getOrCreateLinkedArgValuesMap(String linkedId)
{
if (linkedArgs.containsKey(linkedId)
git://source.jalview.org / jalview.git / blobdiff