public <T extends Loadable> void unconditionallyProcess(T cdo, String key, String value) { try { if (processToken(cdo, key, value)) { commit(); } else { rollback(); Logging.replayParsedMessages(); } Logging.clearParseMessages(); } catch (PersistenceLayerException e) { Logging.errorPrint("Error in token parse: " + e.getLocalizedMessage()); } }
@Test public void testUnbalancedBracket() { PreMultParser parser = new PreMultParser(); try { Prerequisite prereq = parser.parse( "mult", "1,[PREPROFWITHARMOR:1,TYPE.Medium],[PREFEAT:1,Armor Proficiency (Medium)", false, false); fail("Expected unbalanced bracket to be detected."); } catch (PersistenceLayerException e) { assertEquals( "Unbalanced [] in PREMULT '[PREPROFWITHARMOR:1,TYPE.Medium],[PREFEAT:1,Armor Proficiency (Medium)'.", e.getMessage()); } }
@Override protected ParseResult parseNonEmptyToken(LoadContext context, KitTable kitTable, String value) { ParsingSeparator sep = new ParsingSeparator(value, '|'); while (sep.hasNext()) { String thing = sep.next(); if (thing.length() == 0) { return new ParseResult.Fail( getTokenName() + " arguments has invalid pipe separator: " + value, context); } KitGear optionInfo = new KitGear(); for (String s : thing.split("[\\[\\]]")) { if (s.length() == 0) { continue; } int colonLoc = s.indexOf(':'); if (colonLoc == -1) { return new ParseResult.Fail( "Expected colon in Value item: " + s + " within: " + value, context); } String key = s.substring(0, colonLoc); String thingValue = s.substring(colonLoc + 1); try { boolean passed = context.processToken(optionInfo, key, thingValue); if (!passed) { return new ParseResult.Fail("Failure in token: " + key, context); } } catch (PersistenceLayerException e) { return new ParseResult.Fail("Failure in token: " + key + " " + e.getMessage(), context); } } if (!sep.hasNext()) { return new ParseResult.Fail("Odd token count in Value: " + value, context); } String range = sep.next(); if (!processRange(kitTable, optionInfo, range)) { return new ParseResult.Fail( "Invalid Range in Value: " + range + " within " + value, context); } } return ParseResult.SUCCESS; }
private Collection<ACControl> parseACControl(String str) { StringTokenizer st = new StringTokenizer(str, Constants.PIPE); List<ACControl> acTypes = new ArrayList<>(); String token; while (true) { token = st.nextToken(); if (PreParserFactory.isPreReqString(token)) { break; } acTypes.add(new ACControl(token)); if (!st.hasMoreTokens()) { return acTypes; } } if (acTypes.isEmpty()) { Logging.errorPrint("No types found in actype control: " + str); return null; } while (true) { try { PreParserFactory factory = PreParserFactory.getInstance(); Prerequisite prereq = factory.parse(token); for (ACControl acc : acTypes) { acc.addPrerequisite(prereq); } } catch (PersistenceLayerException ple) { Logging.errorPrint(ple.getMessage(), ple); return null; } if (!st.hasMoreTokens()) { break; } token = st.nextToken(); if (!PreParserFactory.isPreReqString(token)) { Logging.errorPrint("ERROR: Type found after" + " PRExxx in actype control: " + str); return null; } } return acTypes; }
@Override public String[] unparse(LoadContext context, CDOMObject obj) { Collection<CDOMReference<? extends CDOMList<?>>> changedLists = context.getListContext().getChangedLists(obj, AbilityList.class); Changes<ListKey<ChooseSelectionActor<?>>> actors = context.getObjectContext().getListChanges(obj, ListKey.GA_CAKEYS); Set<String> returnSet = new TreeSet<String>(); TripleKeyMapToList< Nature, CDOMSingleRef<AbilityCategory>, List<Prerequisite>, CDOMReference<Ability>> m = new TripleKeyMapToList< Nature, CDOMSingleRef<AbilityCategory>, List<Prerequisite>, CDOMReference<Ability>>(); TripleKeyMapToList< Nature, CDOMSingleRef<AbilityCategory>, List<Prerequisite>, CDOMReference<Ability>> clear = new TripleKeyMapToList< Nature, CDOMSingleRef<AbilityCategory>, List<Prerequisite>, CDOMReference<Ability>>(); Changes<ChooseSelectionActor<?>> listChanges = context.getObjectContext().getListChanges(obj, ListKey.NEW_CHOOSE_ACTOR); Collection<ChooseSelectionActor<?>> listAdded = listChanges.getAdded(); if (listAdded != null && !listAdded.isEmpty()) { for (ChooseSelectionActor<?> csa : listAdded) { if (csa.getSource().equals(getTokenName())) { try { AbilitySelector as = (AbilitySelector) csa; StringBuilder sb = new StringBuilder(); sb.append(as.getAbilityCategory().getLSTformat(false)).append(Constants.PIPE); sb.append(as.getNature()).append(Constants.PIPE); sb.append(as.getLstFormat()); returnSet.add(sb.toString()); } catch (PersistenceLayerException e) { context.addWriteMessage(getTokenName() + " encountered error: " + e.getMessage()); return null; } } } } for (CDOMReference ref : changedLists) { AssociatedChanges<CDOMReference<Ability>> changes = context.getListContext().getChangesInList(getTokenName(), obj, ref); if (changes.includesGlobalClear()) { CDOMDirectSingleRef<AbilityList> dr = (CDOMDirectSingleRef<AbilityList>) ref; AbilityList al = dr.get(); StringBuilder sb = new StringBuilder(); sb.append(al.getCategory().getLSTformat(false)).append(Constants.PIPE); sb.append(al.getNature()).append(Constants.PIPE); sb.append(Constants.LST_DOT_CLEAR); returnSet.add(sb.toString()); } MapToList<CDOMReference<Ability>, AssociatedPrereqObject> mtl = changes.getAddedAssociations(); if (mtl != null) { for (CDOMReference<Ability> ab : mtl.getKeySet()) { for (AssociatedPrereqObject assoc : mtl.getListFor(ab)) { Nature nature = assoc.getAssociation(AssociationKey.NATURE); CDOMSingleRef<AbilityCategory> cat = assoc.getAssociation(AssociationKey.CATEGORY); m.addToListFor(nature, cat, assoc.getPrerequisiteList(), ab); } } } mtl = changes.getRemovedAssociations(); if (mtl != null) { for (CDOMReference<Ability> ab : mtl.getKeySet()) { for (AssociatedPrereqObject assoc : mtl.getListFor(ab)) { Nature nature = assoc.getAssociation(AssociationKey.NATURE); CDOMSingleRef<AbilityCategory> cat = assoc.getAssociation(AssociationKey.CATEGORY); clear.addToListFor(nature, cat, assoc.getPrerequisiteList(), ab); } } } } for (Nature nature : m.getKeySet()) { for (CDOMSingleRef<AbilityCategory> category : m.getSecondaryKeySet(nature)) { for (List<Prerequisite> prereqs : m.getTertiaryKeySet(nature, category)) { StringBuilder sb = new StringBuilder(); sb.append(category.getLSTformat(false)).append(Constants.PIPE); sb.append(nature); List<CDOMReference<Ability>> clearList = clear.removeListFor(nature, category, prereqs); if (clearList != null && !clearList.isEmpty()) { sb.append(Constants.PIPE); sb.append(Constants.LST_DOT_CLEAR_DOT); sb.append( ReferenceUtilities.joinLstFormat( clearList, Constants.PIPE + Constants.LST_DOT_CLEAR_DOT)); } sb.append(Constants.PIPE); sb.append( ReferenceUtilities.joinLstFormat( m.getListFor(nature, category, prereqs), Constants.PIPE)); if (prereqs != null && !prereqs.isEmpty()) { sb.append(Constants.PIPE); sb.append(getPrerequisiteString(context, prereqs)); } returnSet.add(sb.toString()); } } } for (Nature nature : clear.getKeySet()) { for (CDOMSingleRef<AbilityCategory> category : clear.getSecondaryKeySet(nature)) { for (List<Prerequisite> prereqs : clear.getTertiaryKeySet(nature, category)) { StringBuilder sb = new StringBuilder(); sb.append(category.getLSTformat(false)).append(Constants.PIPE); sb.append(nature).append(Constants.PIPE).append(Constants.LST_DOT_CLEAR_DOT); sb.append( ReferenceUtilities.joinLstFormat( clear.getListFor(nature, category, prereqs), Constants.PIPE + Constants.LST_DOT_CLEAR_DOT)); if (prereqs != null && !prereqs.isEmpty()) { sb.append(Constants.PIPE); sb.append(getPrerequisiteString(context, prereqs)); } returnSet.add(sb.toString()); } } } Collection<ListKey<ChooseSelectionActor<?>>> addedActors = actors.getAdded(); if (addedActors != null) { for (ListKey<ChooseSelectionActor<?>> lk : addedActors) { Changes<ChooseSelectionActor<?>> cras = context.getObjectContext().getListChanges(obj, lk); for (ChooseSelectionActor<?> cra : cras.getAdded()) { if (getTokenName().equals(cra.getSource())) { try { AbilityTargetSelector ats = (AbilityTargetSelector) cra; StringBuilder sb = new StringBuilder(); sb.append(ats.getAbilityCategory().getLSTformat(false)).append(Constants.PIPE); sb.append(ats.getNature()).append(Constants.PIPE).append(cra.getLstFormat()); List<Prerequisite> prereqs = ats.getPrerequisiteList(); if (prereqs != null && !prereqs.isEmpty()) { sb.append(Constants.PIPE); sb.append(getPrerequisiteString(context, prereqs)); } returnSet.add(sb.toString()); } catch (PersistenceLayerException e) { context.addWriteMessage(getTokenName() + " encountered error: " + e.getMessage()); return null; } } } } } if (returnSet.isEmpty()) { return null; } return returnSet.toArray(new String[returnSet.size()]); }
/* * REFACTOR There is potentially redundant information here - level and PC... * is this ever out of sync or can this method be removed/made private?? */ public double getBonusTo( final String argType, final String argMname, final int asLevel, final PlayerCharacter aPC) { double i = 0; List<BonusObj> rawBonusList = getRawBonusList(aPC); for (int lvl = 1; lvl < asLevel; lvl++) { rawBonusList.addAll(aPC.getActiveClassLevel(this, lvl).getRawBonusList(aPC)); } if ((asLevel == 0) || rawBonusList.isEmpty()) { return 0; } final String type = argType.toUpperCase(); final String mname = argMname.toUpperCase(); for (final BonusObj bonus : rawBonusList) { final StringTokenizer breakOnPipes = new StringTokenizer(bonus.toString().toUpperCase(), Constants.PIPE, false); final String theType = breakOnPipes.nextToken(); if (!theType.equals(type)) { continue; } final String str = breakOnPipes.nextToken(); final StringTokenizer breakOnCommas = new StringTokenizer(str, Constants.COMMA, false); while (breakOnCommas.hasMoreTokens()) { final String theName = breakOnCommas.nextToken(); if (theName.equals(mname)) { final String aString = breakOnPipes.nextToken(); final List<Prerequisite> localPreReqList = new ArrayList<>(); if (bonus.hasPrerequisites()) { localPreReqList.addAll(bonus.getPrerequisiteList()); } // TODO: This code should be removed after the 5.8 release // as the prereqs are processed by the bonus loading code. while (breakOnPipes.hasMoreTokens()) { final String bString = breakOnPipes.nextToken(); if (PreParserFactory.isPreReqString(bString)) { Logging.debugPrint( "Why is this prerequisite '" + bString + "' parsed in '" + getClass().getName() + ".getBonusTo(String,String,int)' rather than in the persistence layer?"); //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$ try { final PreParserFactory factory = PreParserFactory.getInstance(); localPreReqList.add(factory.parse(bString)); } catch (PersistenceLayerException ple) { Logging.errorPrint(ple.getMessage(), ple); } } } // must meet criteria for bonuses before adding them in // TODO: This is a hack to avoid VARs etc in class defs // being qualified for when Bypass class prereqs is // selected. // Should we be passing in the BonusObj here to allow it to // be referenced in Qualifies statements? if (PrereqHandler.passesAll(localPreReqList, aPC, null)) { final double j = aPC.getVariableValue(aString, getQualifiedKey()).doubleValue(); i += j; } } } } return i; }
@Override public String[] unparse(LoadContext context, CDOMObject obj) { Set<String> returnSet = new TreeSet<String>(); List<String> returnList = new ArrayList<String>(); MapToList<List<Prerequisite>, CDOMReference<Ability>> m = new HashMapToList<List<Prerequisite>, CDOMReference<Ability>>(); AbilityCategory category = AbilityCategory.FEAT; Nature nature = Nature.AUTOMATIC; CDOMReference<AbilityList> abilList = AbilityList.getAbilityListReference(category, nature); AssociatedChanges<CDOMReference<Ability>> changes = context.getListContext().getChangesInList(getFullName(), obj, abilList); Collection<CDOMReference<Ability>> removedItems = changes.getRemoved(); if (changes.includesGlobalClear()) { if (removedItems != null && !removedItems.isEmpty()) { context.addWriteMessage( "Non-sensical relationship in " + getTokenName() + ": global .CLEAR and local .CLEAR. performed"); return null; } returnList.add(Constants.LST_DOT_CLEAR); } else if (removedItems != null && !removedItems.isEmpty()) { returnList.add( Constants.LST_DOT_CLEAR_DOT + ReferenceUtilities.joinLstFormat(removedItems, "|.CLEAR.", true)); } Changes<ChooseSelectionActor<?>> listChanges = context.getObjectContext().getListChanges(obj, ListKey.NEW_CHOOSE_ACTOR); Collection<ChooseSelectionActor<?>> listAdded = listChanges.getAdded(); if (listAdded != null && !listAdded.isEmpty()) { for (ChooseSelectionActor<?> csa : listAdded) { if (csa.getSource().equals(SOURCE)) { try { returnList.add(csa.getLstFormat()); } catch (PersistenceLayerException e) { context.addWriteMessage(getTokenName() + " encountered error: " + e.getMessage()); return null; } } } } MapToList<CDOMReference<Ability>, AssociatedPrereqObject> mtl = changes.getAddedAssociations(); if (mtl != null) { for (CDOMReference<Ability> ab : mtl.getKeySet()) { for (AssociatedPrereqObject assoc : mtl.getListFor(ab)) { m.addToListFor(assoc.getPrerequisiteList(), ab); } } } for (List<Prerequisite> prereqs : m.getKeySet()) { StringBuilder sb = new StringBuilder(); sb.append(ReferenceUtilities.joinLstFormat(m.getListFor(prereqs), Constants.PIPE)); if (prereqs != null && !prereqs.isEmpty()) { sb.append(Constants.PIPE); sb.append(getPrerequisiteString(context, prereqs)); } returnSet.add(sb.toString()); } returnList.addAll(returnSet); return returnList.toArray(new String[returnList.size()]); }