@Override
public void setUp() throws Exception {
facet = new HandsFacet();
super.setUp();
DataSetID cid = DataSetID.getID();
id = CharID.getID(cid);
altid = CharID.getID(cid);
facet.setRaceFacet(rfacet);
facet.setTemplateFacet(tfacet);
}
@Override
public void setUp() throws Exception {
super.setUp();
DataSetID cid = DataSetID.getID();
id = CharID.getID(cid);
altid = CharID.getID(cid);
facet = getMockFacet();
facet.setRaceFacet(rfacet);
facet.setTemplateFacet(tfacet);
facet.setFormulaResolvingFacet(new FormulaResolvingFacet());
bonusInfo = new HashMap<CharID, Double>();
staticSetUp();
}
public abstract class LoadContextInst implements LoadContext {
private static final PrerequisiteWriter PREREQ_WRITER = new PrerequisiteWriter();
private final DataSetID datasetID = DataSetID.getID();
private final AbstractListContext list;
private final AbstractObjectContext obj;
private final AbstractReferenceContext ref;
private final List<Campaign> campaignList = new ArrayList<Campaign>();
private int writeMessageCount = 0;
private final TokenSupport support = new TokenSupport();
private final List<Object> dontForget = new ArrayList<Object>();
// Per file
private URI sourceURI;
// Per file
private CDOMObject stateful;
static {
FacetInitialization.initialize();
}
public LoadContextInst(
AbstractReferenceContext rc, AbstractListContext lc, AbstractObjectContext oc) {
if (rc == null) {
throw new IllegalArgumentException("ReferenceContext cannot be null");
}
if (lc == null) {
throw new IllegalArgumentException("ListContext cannot be null");
}
if (oc == null) {
throw new IllegalArgumentException("ObjectContext cannot be null");
}
ref = rc;
list = lc;
obj = oc;
}
public void addWriteMessage(String string) {
Logging.errorPrint("!!" + string);
/*
* TODO Need to find a better solution for what happens during write...
*/
writeMessageCount++;
}
public int getWriteMessageCount() {
return writeMessageCount;
}
/**
* Sets the extract URI. This is a shortcut for setting the URI on both the graph and obj members.
*
* @param extractURI
*/
public void setExtractURI(URI extractURI) {
getObjectContext().setExtractURI(extractURI);
getReferenceContext().setExtractURI(extractURI);
getListContext().setExtractURI(extractURI);
}
/**
* Sets the source URI. This is a shortcut for setting the URI on both the graph and obj members.
*
* @param sourceURI
*/
public void setSourceURI(URI sourceURI) {
this.sourceURI = sourceURI;
getObjectContext().setSourceURI(sourceURI);
getReferenceContext().setSourceURI(sourceURI);
getListContext().setSourceURI(sourceURI);
clearStatefulInformation();
Logging.debugPrint("Starting Load of " + sourceURI);
}
public URI getSourceURI() {
return sourceURI;
}
/*
* Get the type of context we're running in (either Editor or Runtime)
*/
public abstract String getContextType();
public AbstractObjectContext getObjectContext() {
return obj;
}
public AbstractListContext getListContext() {
return list;
}
public void commit() {
getListContext().commit();
getObjectContext().commit();
}
public void rollback() {
getListContext().rollback();
getObjectContext().rollback();
}
public void resolveDeferredTokens() {
for (DeferredToken<? extends Loadable> token : support.getDeferredTokens()) {
processRes(token);
}
commit();
}
private <T extends Loadable> void processRes(DeferredToken<T> token) {
Class<T> cl = token.getDeferredTokenClass();
Collection<? extends ReferenceManufacturer> mfgs = getReferenceContext().getAllManufacturers();
for (ReferenceManufacturer<? extends T> rm : mfgs) {
if (cl.isAssignableFrom(rm.getReferenceClass())) {
for (T po : rm.getAllObjects()) {
token.process(this, po);
}
for (T po : rm.getDerivativeObjects()) {
token.process(this, po);
}
}
}
}
public void resolvePostDeferredTokens() {
Collection<? extends ReferenceManufacturer> mfgs = getReferenceContext().getAllManufacturers();
for (PostDeferredToken<? extends Loadable> token : TokenLibrary.getPostDeferredTokens()) {
processPostRes(token, mfgs);
}
}
private <T extends Loadable> void processPostRes(
PostDeferredToken<T> token, Collection<? extends ReferenceManufacturer> mfgs) {
Class<T> cl = token.getDeferredTokenClass();
for (ReferenceManufacturer<? extends T> rm : mfgs) {
if (cl.isAssignableFrom(rm.getReferenceClass())) {
for (T po : rm.getAllObjects()) {
this.setSourceURI(po.getSourceURI());
token.process(this, po);
}
}
}
}
public <T extends CDOMObject> PrimitiveCollection<T> getChoiceSet(
SelectionCreator<T> sc, String value) {
try {
return ChoiceSetLoadUtilities.getChoiceSet(this, sc, value);
} catch (ParsingSeparator.GroupingMismatchException e) {
Logging.errorPrint("Group Mismatch in getting ChoiceSet: " + e.getMessage());
return null;
}
}
public <T extends CDOMObject> PrimitiveCollection<T> getPrimitiveChoiceFilter(
SelectionCreator<T> sc, String key) {
return ChoiceSetLoadUtilities.getPrimitive(this, sc, key);
}
public <T> ParseResult processSubToken(T cdo, String tokenName, String key, String value) {
return support.processSubToken(this, cdo, tokenName, key, value);
}
public <T extends Loadable> boolean processToken(T derivative, String typeStr, String argument)
throws PersistenceLayerException {
return support.processToken(this, derivative, typeStr, argument);
}
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());
}
}
/**
* Produce the LST code for any occurrences of subtokens of the parent token.
*
* @param <T> The type of object to be processed, generally a CDOMObject.
* @param cdo The object to be partially unparsed
* @param tokenName The name of the parent token
* @return An array of LST code 'fields' all of which are subtokens of the parent token.
*/
public <T> String[] unparseSubtoken(T cdo, String tokenName) {
return support.unparseSubtoken(this, cdo, tokenName);
}
public <T> Collection<String> unparse(T cdo) {
return support.unparse(this, cdo);
}
public <T extends CDOMObject> T cloneConstructedCDOMObject(T cdo, String newName) {
T newObj = getObjectContext().cloneConstructedCDOMObject(cdo, newName);
getReferenceContext().importObject(newObj);
return newObj;
}
/**
* Create a copy of a CDOMObject duplicating any references to the old object. (e.g. Spell, Domain
* etc)
*
* <p>Package protected rather than private for testing only
*
* @param cdo The original object being copied.
* @param newName The name that should be given to the new object.
* @return The newly created CDOMObject.
*/
@SuppressWarnings("unchecked")
<T extends CDOMObject> T cloneInMasterLists(T cdo, String newName) {
T newObj;
try {
newObj = (T) cdo.clone();
newObj.setName(newName);
getListContext().cloneInMasterLists(cdo, newObj);
} catch (CloneNotSupportedException e) {
Logging.errorPrint("Failed to clone " + cdo, e);
return null;
}
return newObj;
}
public String getPrerequisiteString(Collection<Prerequisite> prereqs) {
try {
return PREREQ_WRITER.getPrerequisiteString(prereqs);
} catch (PersistenceLayerException e) {
addWriteMessage("Error writing Prerequisite: " + e);
return null;
}
}
public CampaignSourceEntry getCampaignSourceEntry(Campaign source, String value) {
return CampaignSourceEntry.getNewCSE(source, sourceURI, value);
}
public void clearStatefulInformation() {
stateful = null;
}
public boolean addStatefulToken(String s) throws PersistenceLayerException {
int colonLoc = s.indexOf(':');
if (colonLoc == -1) {
Logging.errorPrint("Found invalid stateful token: " + s);
return false;
}
if (stateful == null) {
stateful = new ObjectCache();
}
return processToken(
stateful, s.substring(0, colonLoc).intern(), s.substring(colonLoc + 1).intern());
}
public void addStatefulInformation(CDOMObject target) {
if (stateful != null) {
target.overlayCDOMObject(stateful);
}
}
public void setLoaded(List<Campaign> campaigns) {
campaignList.clear();
campaignList.addAll(campaigns);
}
public abstract boolean consolidate();
public DataSetID getDataSetID() {
return datasetID;
}
public void loadCampaignFacets() {
FacetLibrary.getFacet(DataSetInitializationFacet.class).initialize(this);
}
public void forgetMeNot(CDOMReference<?> cdr) {
dontForget.add(cdr);
}
public AbstractReferenceContext getReferenceContext() {
return ref;
}
public List<Campaign> getLoadedCampaigns() {
return Collections.unmodifiableList(campaignList);
}
public ReferenceManufacturer<? extends Loadable> getManufacturer(String firstToken) {
return ReferenceContextUtilities.getManufacturer(getReferenceContext(), firstToken);
}
public <T extends CDOMObject> T performCopy(T object, String copyName) {
T copy = ref.performCopy(object, copyName);
list.cloneInMasterLists(object, copy);
return copy;
}
}