Menu
▾
▴
[pcgen-commit-svn] SF.net SVN: pcgen: [3340] branches/cdom/code/src/java
|
From: <th...@us...> - 2007-07-07 15:51:49
|
Revision: 3340
http://svn.sourceforge.net/pcgen/?rev=3340&view=rev
Author: thpr
Date: 2007-07-07 08:51:50 -0700 (Sat, 07 Jul 2007)
Log Message:
-----------
CDOM: Doc updates from feedback (thanks Koen)
Some token updates
Modified Paths:
--------------
branches/cdom/code/src/java/pcgen/base/enumeration/AbstractSequencedConstantFactory.java
branches/cdom/code/src/java/pcgen/base/enumeration/TypeSafeConstant.java
branches/cdom/code/src/java/pcgen/base/lang/Internationalization.java
branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java
branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java
branches/cdom/code/src/java/plugin/lsttokens/TypeLst.java
branches/cdom/code/src/java/plugin/lsttokens/auto/EquipToken.java
branches/cdom/code/src/java/plugin/lsttokens/equipment/AlteqmodToken.java
branches/cdom/code/src/java/plugin/lsttokens/equipment/AlttypeToken.java
Added Paths:
-----------
branches/cdom/code/src/java/pcgen/cdom/helper/FollowerLimit.java
Modified: branches/cdom/code/src/java/pcgen/base/enumeration/AbstractSequencedConstantFactory.java
===================================================================
--- branches/cdom/code/src/java/pcgen/base/enumeration/AbstractSequencedConstantFactory.java 2007-07-07 12:17:00 UTC (rev 3339)
+++ branches/cdom/code/src/java/pcgen/base/enumeration/AbstractSequencedConstantFactory.java 2007-07-07 15:51:50 UTC (rev 3340)
@@ -31,6 +31,19 @@
import pcgen.base.lang.CaseInsensitiveString;
import pcgen.base.lang.UnreachableError;
+/**
+ * @author Tom Parker <th...@us...>
+ *
+ * An AbstractSequencedConstantFactory is a framework used to develop non-enum
+ * (meaning expandable) Type Safe Constants that have additional sequencing
+ * information beyond the ordinal of the Type Safe Constant. Typically, this
+ * would be used to create a sequence of objects where the sequence numbers are
+ * not sequential (but using this class makes the ordinals sequential)
+ *
+ * @param <T>
+ * The sequenced type (This should be the class that extends the
+ * Factory)
+ */
public abstract class AbstractSequencedConstantFactory<T extends TypeSafeConstant & SequencedType>
implements Serializable
{
@@ -83,7 +96,7 @@
{
throw new IllegalArgumentException(
"Attempt to redefine constant value " + i + " to " + s
- + " was " + o.string);
+ + ", value was " + o.string);
}
obj = o.constant;
}
@@ -257,10 +270,36 @@
return null;
}
+ /**
+ * Returns a new Constant of the given class.
+ *
+ * The extending class is responsible for ensuring that the Constant is
+ * given a unique ordinal.
+ *
+ * @param name
+ * The String identifier for the Constant to be built
+ * @param i
+ * The sequence number of the constant to be built.
+ * @return A new Constant, with an ordinal that is unique to the child
+ * class.
+ */
protected abstract T getConstantInstance(String name, int i);
+ /**
+ * Must return the class that extends the AbstractSequencedConstantFactory.
+ * This is done in order to allow any constants declared as "public static
+ * final" constants within the class that extends the
+ * AbstractSequencedConstantFactory to be integrated into the Constant pool.
+ *
+ * @return the class that extends the AbstractSequencedConstantFactory
+ */
protected abstract Class<T> getConstantClass();
+ /**
+ * Actually build the set of Constants, using any "public static final"
+ * constants within the child (extending) class as initial values in the
+ * Constant pool.
+ */
private void buildMap()
{
typeMap = new TreeMap<Integer, SCFValue<T>>();
@@ -284,8 +323,8 @@
{
throw new UnreachableError(
"Attempt to redefine constant value " + i
- + " to " + fields[i].getName() + " was "
- + typeMap.get(in));
+ + " to " + fields[i].getName()
+ + ", value was " + typeMap.get(in));
}
typeMap.put(in, new SCFValue<T>(fields[i].getName(),
tObj));
@@ -327,6 +366,13 @@
* Clears all of the Constants defined by this class. Note that this does
* not remove any Constants declared in the Constant class (as those are
* considered 'permanent' members of the Sequenced Constant collection.
+ *
+ * Note that this *will not* reset the ordinal count, because that is a
+ * dangerous operation. As there could be outstanding references to
+ * constants that would be removed from the Constant pool, no reuse of
+ * ordinals is driven by this method. As a result, calling this method may
+ * result in a Constant Pool which does not have sequentially numbered
+ * ordinal values.
*/
public void clearConstants()
{
@@ -349,6 +395,15 @@
return Collections.unmodifiableList(l);
}
+ /**
+ * This is simply used as a holder of values in the Constant pool. This is
+ * required in order to store both the String value and the Constant itself,
+ * as the Constants are stored in the AbstractSequencedConstantFactory by
+ * their sequence number.
+ *
+ * @param <HET>
+ * The constant type
+ */
protected static class SCFValue<HET extends SequencedType>
{
public final CaseInsensitiveString string;
Modified: branches/cdom/code/src/java/pcgen/base/enumeration/TypeSafeConstant.java
===================================================================
--- branches/cdom/code/src/java/pcgen/base/enumeration/TypeSafeConstant.java 2007-07-07 12:17:00 UTC (rev 3339)
+++ branches/cdom/code/src/java/pcgen/base/enumeration/TypeSafeConstant.java 2007-07-07 15:51:50 UTC (rev 3340)
@@ -22,11 +22,19 @@
/**
* A TypeSafeConstant is an object which will provide a unique integer
* identifier to every instance of that class (not unique to every
- * TypeSafeConstant). This emulates behavior by the enum system in Java 1.5+.
- * Note that the identifier should be unique per virtual machine; thus
- * serialization and other forms of persistence of classes must ensure the
- * uniqueness of identifiers of a TypeSafeConstant.
+ * TypeSafeConstant).
*
+ * As an example, If Classes A and B both extend TypeSafeConstant, then there
+ * may be an instance of Class A that has ordinal 1 and an instance of Class B
+ * that has ordinal 1, but only one instance of each class may have any ordinal.
+ * (Two instances of Class A may not share ordinal 1 and still respect the
+ * TypeSafeConstant interface)
+ *
+ * This emulates behavior by the enum system in Java 1.5+. Note that the
+ * identifier should be unique per virtual machine; thus serialization and other
+ * forms of persistence of classes must ensure the uniqueness of identifiers of
+ * a TypeSafeConstant.
+ *
* It is considered good behavior for a TypeSafeConstant to begin the ordinal
* count at zero. There may be an expectation by classes that use
* TypeSafeConstants that expect this behavior. In that case, such behavioral
Modified: branches/cdom/code/src/java/pcgen/base/lang/Internationalization.java
===================================================================
--- branches/cdom/code/src/java/pcgen/base/lang/Internationalization.java 2007-07-07 12:17:00 UTC (rev 3339)
+++ branches/cdom/code/src/java/pcgen/base/lang/Internationalization.java 2007-07-07 15:51:50 UTC (rev 3340)
@@ -35,7 +35,6 @@
// Can't instantiate
}
- /** These are for the Internationalization project. */
private static String language = "en"; //$NON-NLS-1$
private static String country = "US"; //$NON-NLS-1$
Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java
===================================================================
--- branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java 2007-07-07 12:17:00 UTC (rev 3339)
+++ branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java 2007-07-07 15:51:50 UTC (rev 3340)
@@ -33,6 +33,7 @@
import pcgen.cdom.base.CDOMReference;
import pcgen.cdom.base.CDOMSimpleSingleRef;
import pcgen.cdom.helper.Capacity;
+import pcgen.cdom.helper.FollowerLimit;
import pcgen.cdom.helper.Qualifier;
import pcgen.cdom.helper.Quality;
import pcgen.core.Alignment;
@@ -105,6 +106,8 @@
public static final ListKey<Qualifier> QUALIFY = new ListKey<Qualifier>();
+ public static final ListKey<FollowerLimit> FOLLOWERS = new ListKey<FollowerLimit>();
+
/** Private constructor to prevent instantiation of this class */
private ListKey()
{
Added: branches/cdom/code/src/java/pcgen/cdom/helper/FollowerLimit.java
===================================================================
--- branches/cdom/code/src/java/pcgen/cdom/helper/FollowerLimit.java (rev 0)
+++ branches/cdom/code/src/java/pcgen/cdom/helper/FollowerLimit.java 2007-07-07 15:51:50 UTC (rev 3340)
@@ -0,0 +1,29 @@
+package pcgen.cdom.helper;
+
+import pcgen.base.formula.Formula;
+import pcgen.cdom.base.CDOMSimpleSingleRef;
+import pcgen.core.CompanionList;
+
+public class FollowerLimit
+{
+
+ private final CDOMSimpleSingleRef<CompanionList> ref;
+ private final Formula f;
+
+ public FollowerLimit(CDOMSimpleSingleRef<CompanionList> cl, Formula limit)
+ {
+ ref = cl;
+ f = limit;
+ }
+
+ public CDOMSimpleSingleRef<CompanionList> getCompanionList()
+ {
+ return ref;
+ }
+
+ public Formula getValue()
+ {
+ return f;
+ }
+
+}
Modified: branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java
===================================================================
--- branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java 2007-07-07 12:17:00 UTC (rev 3339)
+++ branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java 2007-07-07 15:51:50 UTC (rev 3340)
@@ -30,6 +30,8 @@
import pcgen.cdom.base.CDOMSimpleSingleRef;
import pcgen.cdom.base.Constants;
import pcgen.cdom.base.FormulaFactory;
+import pcgen.cdom.enumeration.ListKey;
+import pcgen.cdom.helper.FollowerLimit;
import pcgen.core.CompanionList;
import pcgen.core.PObject;
import pcgen.persistence.LoadContext;
@@ -150,15 +152,11 @@
+ " cannot be empty");
return false;
}
- Formula num = FormulaFactory.getFormulaFor(followerNumber);
-
CDOMSimpleSingleRef<CompanionList> cl =
context.ref.getCDOMReference(CompanionList.class, followerType);
-
- /*
- * TODO This is NOT a slot, since it sets a limit. It is really a
- * Modifier, and should be stored as such...
- */
+ Formula num = FormulaFactory.getFormulaFor(followerNumber);
+ context.obj.addToList(obj, ListKey.FOLLOWERS,
+ new FollowerLimit(cl, num));
return true;
}
Modified: branches/cdom/code/src/java/plugin/lsttokens/TypeLst.java
===================================================================
--- branches/cdom/code/src/java/plugin/lsttokens/TypeLst.java 2007-07-07 12:17:00 UTC (rev 3339)
+++ branches/cdom/code/src/java/plugin/lsttokens/TypeLst.java 2007-07-07 15:51:50 UTC (rev 3340)
@@ -108,8 +108,8 @@
}
/*
* TODO is it a problem that this unconditionally adds, as Type
- * is a SET? This problem exists elsewhere (in the TYPE token,
- * for example), so I doubt this is a serious issue.
+ * is a SET? This problem exists elsewhere (in the ALTTYPE
+ * token, for example), so I doubt this is a serious issue.
* Additionally, the tests that take place are for .contains,
* which will pass even if multiple items are present. The
* problem exists in removal - what if a type exists multiple
Modified: branches/cdom/code/src/java/plugin/lsttokens/auto/EquipToken.java
===================================================================
--- branches/cdom/code/src/java/plugin/lsttokens/auto/EquipToken.java 2007-07-07 12:17:00 UTC (rev 3339)
+++ branches/cdom/code/src/java/plugin/lsttokens/auto/EquipToken.java 2007-07-07 15:51:50 UTC (rev 3340)
@@ -206,7 +206,7 @@
edge.setAssociation(AssociationKey.EQUIPMENT_NATURE,
EquipmentNature.AUTOMATIC);
edge.setAssociation(AssociationKey.QUANTITY, INTEGER_ONE);
- // TODO Need to account for these
+ // TODO Need to account for output index??
// newEq.setOutputIndex(aList.size());
}
Modified: branches/cdom/code/src/java/plugin/lsttokens/equipment/AlteqmodToken.java
===================================================================
--- branches/cdom/code/src/java/plugin/lsttokens/equipment/AlteqmodToken.java 2007-07-07 12:17:00 UTC (rev 3339)
+++ branches/cdom/code/src/java/plugin/lsttokens/equipment/AlteqmodToken.java 2007-07-07 15:51:50 UTC (rev 3340)
@@ -75,7 +75,13 @@
}
if (Constants.LST_NONE.equals(value))
{
- //TODO Does this have a clearing effect??
+ /*
+ * As strange as this sounds, this does not have a clearning effect,
+ * it is simply ignored.
+ *
+ * CONSIDER This should probably be a warning of useless behavior -
+ * thpr 7/7/07
+ */
return true;
}
if (hasIllegalSeparator('.', value))
Modified: branches/cdom/code/src/java/plugin/lsttokens/equipment/AlttypeToken.java
===================================================================
--- branches/cdom/code/src/java/plugin/lsttokens/equipment/AlttypeToken.java 2007-07-07 12:17:00 UTC (rev 3339)
+++ branches/cdom/code/src/java/plugin/lsttokens/equipment/AlttypeToken.java 2007-07-07 15:51:50 UTC (rev 3340)
@@ -122,7 +122,15 @@
removeType = false;
}
/*
- * BUG TODO Not sure how to handle this - it's a SET!
+ * Type is a set, so we're trying to avoid duplication here.
+ * This isn't a pretty way to do it (given that we're storing it
+ * in a ListKey, not a SetKey [as those don't exist]), but it
+ * functions well enough.
+ *
+ * TODO The problem here is that the object is being directly
+ * addressed (eq.containsInList), which is improper in a
+ * token... thus this should probably ignore the fact that it's
+ * a Set, and just add it a second time??
*/
else if (!eq.containsInList(ListKey.ALT_TYPE, typeCon))
{
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|