newAllQuestions = new LinkedHashMap<>();
for (Question q : allQuestions.values()) {
q.updateTag();
newAllQuestions.put(q.getTag(), q);
}
allQuestions = newAllQuestions;
// recursively update children
for (Interview i : children) {
i.updateTags();
}
}
//----- adding subinterviews and questions ------------------------
void add(Interview child) {
children.add(child);
}
void add(Question question) {
String qTag = question.getTag();
Question prev = allQuestions.put(qTag, question);
if (prev != null)
throw new IllegalArgumentException("duplicate questions for tag: " + qTag);
}
//----- versioning ----------------------------------------
/**
* This method is being used to toggle changes which are not
* backwards compatible with existing interviews. Changing this value
* after you first initialize the top-level interview object is not
* recommended or supported. This method should be called as soon as
* possible during construction. It is recommended that you select
* the most recent version possible when developing a new interview.
* As this interview ages and the harness libraries progress, the
* interview should remain locked at the current behavior. Each subsequent
* version works under the assumption that the behavior of all previous
* versions is also enabled, there is no way to select individual behaviors.
*
*
* The version numbers are effectively an indication of the harness version
* where the behavior was added (32 = 3.2, 50 = 5.0). Gaps in numbering
* would indicate that no incompatible behavior changes occurred.
*
*
*
* Select PRE_32 behavior to select behaviors prior to 3.2.
*
*
*
* In Version 32, the first versioned semantic change was introduced.
* Interviews will generally request SEMANTIC_PRE_32 for old semantics.
* This version has the behavioral changes:
*
* - ChoiceQuestion
* - If the value is reset to null, resulting in the value being
* "cleared", new behavior simply calls
clear() to do this. Old
* behavior was to select either the last value or first possible
* choice (from the array of possible choices) THEN call updatePath()
* and setEdited().
* - FileListQuestion
* - During construction,
clear() will be called before the
* default value is set, in older implementations it was not called.
* - FileQuestion
* - During construction,
clear() will be called before the
* default value is set, in older implementations it was not called.
*
*
*
*
* In Version 43 changes to the way in which export() works were
* introduced. Earlier than this version, the list of questions to call
* export() upon with pre-generated as a flattened list of
* Questions (with all sub-interviews removed). In 43 and later, the
* structure is NOT flattened, but instead exporting will recurse into
* sub-interviews by calling its (the Interview) export().
* Additionally, questions which are on the path but hidden will be exported.
* Note that being hidden is not the same at being disabled.
*
*
*
* In Version 50, FileListQuestion has significantly altered processing
* of filters. See the {@link com.sun.interview.FileListQuestion#isValueValid}
* for an explanation.
*
*
* @param value Which semantics the interview should use.
* @see #SEMANTIC_PRE_32
* @see #SEMANTIC_VERSION_32
* @see #SEMANTIC_VERSION_43
* @see #SEMANTIC_VERSION_50
* @see #SEMANTIC_MAX_VERSION
* @since 3.2
* @see #getInterviewSemantics
*/
public void setInterviewSemantics(int value) {
if (value <= SEMANTIC_MAX_VERSION)
semantics = value;
}
/**
* Determine which semantics are being used for interview and question
* behavior. This is important because new behavior in future versions
* can cause unanticipated code flow, resulting in incorrect behavior of
* existing code.
* @return The semantics that the interview is currently using.
* @see #setInterviewSemantics
* @since 3.2
*/
public int getInterviewSemantics() {
return semantics;
}
//----- external value management ----------------------------------------
/**
* Store an "external" value into the configuration. This is a value
* not associated with any interview question and in a separate namespace
* than all the question keys.
* @param key The name of the key to store.
* @param value The value associated with the given key. Null to remove
* the property from the current set of properties for this interview.
* @return The old value of this property, null if not previously set.
* @see #retrieveProperty
*/
public String storeProperty(String key, String value) {
if (getParent() != null)
return getParent().storeProperty(key, value);
else {
if (value == null) {
// remove
if (extraValues == null)
return null;
else
return extraValues.remove(key);
}
if (extraValues == null)
extraValues = new HashMap<>();
return extraValues.put(key, value);
}
}
/**
* Store a template value into the configuration.
* @param key The name of the key to store.
* @param value The value associated with the given key.
* @return The old value of this property, null if not previously set.
*/
public String storeTemplateProperty(String key, String value) {
if (getParent() != null)
return getParent().storeTemplateProperty(key, value);
else {
ensureTemValuesInitialized();
return templateValues.put(key, value);
}
}
/**
* Clear a previous template properties and store the new into the configuration.
* @param props The properties to store.
*/
public void storeTemplateProperties(Map props) {
if (getParent() != null)
getParent().storeTemplateProperties(props);
else {
ensureTemValuesInitialized();
templateValues.clear();
templateValues.putAll(props);
}
}
/**
* Retrieve a property from the collection of "external" values being
* stored in the configuration.
* @param key The key which identifies the property to retrieve.
* @return The value associated with the given key, or null if it is not
* found.
* @see #storeProperty
*/
public String retrieveProperty(String key) {
if (getParent() != null)
return getParent().retrieveProperty(key);
else {
if (extraValues == null)
return null;
return extraValues.get(key);
}
}
/**
* Retrieve a template property.
* @param key The key which identifies the property to retrieve.
* @return The value associated with the given key, or null if it is not
* found.
*/
public String retrieveTemplateProperty(String key) {
if (getParent() != null)
return getParent().retrieveTemplateProperty(key);
else {
ensureTemValuesInitialized();
return templateValues.get(key);
}
}
public Set retrieveTemplateKeys() {
if (getParent() != null)
return getParent().retrieveTemplateKeys();
else {
ensureTemValuesInitialized();
return templateValues.keySet();
}
}
/**
* Retrieve set of keys for the "external" values being stored in the
* configuration.
* @return The set of keys currently available. Null if there are none.
* All values in the Set are Strings.
* @see #storeProperty
* @see #retrieveProperty
*/
public Set getPropertyKeys() {
if (getParent() != null)
return parent.getPropertyKeys();
else {
if (extraValues == null || extraValues.size() == 0)
return null;
return extraValues.keySet();
}
}
/**
* Get a (shallow) copy of the current "external" values.
* @see #storeProperty
* @see #retrieveProperty
* @return The copy of the properties, null if there are none.
*/
public Map getExternalProperties() {
if (extraValues != null)
return new HashMap<>(extraValues);
else
return null;
}
/**
* @see #load(Map)
*/
private void loadExternalValues(Map data) {
if (extraValues != null) {
extraValues.clear();
}
Set keys = data.keySet();
for (String key : keys) {
// look for special external value keys
// should consider removing it from data, is it safe to alter
// that object?
if (key.startsWith(EXTERNAL_PREF)) {
if (extraValues == null)
extraValues = new HashMap<>();
String val = data.get(key);
// store it, minus the special prefix
extraValues.put(key.substring(EXTERNAL_PREF.length()), val);
}
} // while
}
private void loadTemplateValues(Map data) {
if (templateValues != null) {
templateValues.clear();
}
Set keys = data.keySet();
for (String key : keys) {
if (key.startsWith(TEMPLATE_PREF)) {
ensureTemValuesInitialized();
String val = data.get(key);
// store it, minus the special prefix
templateValues.put(key.substring(TEMPLATE_PREF.length()), val);
}
}
}
public void propagateTemplateForAll() {
ensureTemValuesInitialized();
for (Question q : getAllQuestions().values()) {
q.load(templateValues);
}
}
//----- internal utilities ----------------------------------------
private void ensureTemValuesInitialized() {
if (templateValues == null) {
templateValues = new HashMap<>();
}
}
private void ensurePathInitialized() {
if (path == null) {
path = new Path();
hiddenPath = new ArrayList<>();
if (parent == null)
rawPath = new Path();
reset();
}
if (parent == null && rawPath == null)
rawPath = new Path();
}
private Question lookup(String tag) {
Question q = allQuestions.get(tag);
// if q is null, search children till we find it
for (int i = 0; i < children.size() && q == null; i++) {
Interview child = children.elementAt(i);
q = child.lookup(tag);
}
return q;
}
/**
* Determine if this is the root interview.
* @return True if this is the root interview.
*/
public boolean isRoot() {
return parent == null;
}
/**
* Get the root interview object for an interview series.
* Some parts of the data are associated only with the root interview, such
* as tags, external values and the {@link Interview#getRawPath} information.
*/
public Interview getRoot() {
/*
Interview i = this;
while (i.root != this)
i = i.parent;
return i;
*/
return root;
}
/**
* Update the current path, typically because a response to
* a question has changed.
*/
public void updatePath() {
root.updatePath0(root.firstQuestion);
}
/**
* Update the current path, typically because a response to
* a question has changed.
* @param q The question that was changed.
*/
public void updatePath(Question q) {
root.updatePath0(q);
}
private void updatePath0(Question q) {
ASSERT(root == this);
if (!updateEnabled) {
// avoid frequent updates during load
return;
}
if (path == null) {
// path has not been initialized yet, so no need to update it
return;
}
// version 4.3 and later allow path reevaluation even if the question
// isn't an active question (probably disabled)
if (semantics < SEMANTIC_VERSION_43 && !pathContains(q)) {
return;
}
// keep a copy of the current path so that if the current
// question is no longer on the path at the end of the update
// we can adjust it as best we can.
Question[] currPath = getPathToCurrent();
trimPath(q);
predictPath(q);
//showPath(this, q, 0);
verifyPredictPath();
if (!pathContains(currPath[currPath.length - 1]))
setCurrentQuestionFromPath(currPath);
notifyPathUpdated();
}
private void verifyPredictPath(){
for (Interview i : getInterviews()) {
if (i.path != null && i.currIndex >= i.path.size()) {
i.currIndex = i.path.size() - 1;
}
}
}
/* useful debug routine
private void showPath(Interview i, Question q, int depth) {
for (int d = 0; d < depth; d++)
System.err.print(" ");
System.err.println(i.getClass().getName() + " " + i.getTag());
for (int p = 0; p < i.path.size(); p++) {
for (int d = 0; d < depth; d++)
System.err.print(" ");
Question pq = i.path.questionAt(p);
System.err.print(p + ": " + pq.getClass().getName() + " " + pq.getTag());
if (pq == q)
System.err.print(" *");
System.err.println();
if (pq instanceof InterviewQuestion)
showPath(((InterviewQuestion)pq).getTargetInterview(), q, depth+1);
}
}
*/
private void trimPath(Question q) {
Object o = q;
Interview i = q.getInterview();
while (i != null) {
// try to find o within i's path
i.ensurePathInitialized();
Path iPath = i.path;
int oIndex = -1;
for (int pi = 0; pi < iPath.size(); pi++) {
Question qq = iPath.questionAt(pi);
if (qq == o
|| (qq instanceof InterviewQuestion
&& ((InterviewQuestion) qq).getTargetInterview() == o)) {
oIndex = pi;
break;
}
}
// if not found, this question is not on path
// otherwise, trim i's path to end with o
if (oIndex == -1)
return;
else
iPath.setSize(oIndex + 1);
// repeat with caller, all the way up the call stack
o = i;
i = (i.caller == null ? null : i.caller.getInterview());
}
}
private void predictPath(Question q) {
// start filling out path
Interview i = q.getInterview();
i.ensurePathInitialized();
q = predictNext(q);
while (true) {
// note: multiple exit conditions within loop body
if (q == null || pathContains(q))
break;
else if (q instanceof FinalQuestion) {
// end of an interview; continue in caller if available
i.path.addQuestion(q);
i.root.rawPath.addQuestion(q);
if (i.caller == null) {
break;
}
else {
q = i.caller.getNext();
i = i.caller.getInterview();
}
}
else if (q instanceof InterviewQuestion) {
InterviewQuestion iq = (InterviewQuestion)q;
Interview i2 = iq.getTargetInterview();
if (pathContains(i2))
break;
else if (i2 instanceof ListQuestion.Body) {
// no need to predict the body, right?
// because it was done in predictNext()
i2.caller = iq;
i.path.addQuestion(iq);
i.root.rawPath.addQuestion(iq);
q = (i2.path.lastQuestion() instanceof FinalQuestion ? iq.getNext() : null);
}
else {
i2.caller = iq;
if (i2.path == null) {
i2.path = new Path();
i2.hiddenPath = new ArrayList<>();
}
else {
i2.path.clear();
i2.hiddenPath.clear();
}
i.path.addQuestion(iq);
i.root.rawPath.addQuestion(iq);
i = i2;
q = i2.firstQuestion;
}
}
else {
if (q.isEnabled())
i.path.addQuestion(q);
else if (q.isHidden() && !root.hiddenPath.contains(q))
root.hiddenPath.add(q);
if (root.rawPath.indexOf(q) == -1)
i.root.rawPath.addQuestion(q);
q = predictNext(q);
}
}
}
private Question predictNext(Question q) {
if (q.isEnabled() && !q.isValueValid())
return null;
if (q instanceof ListQuestion && q.isEnabled()) {
final ListQuestion lq = (ListQuestion) q;
if (lq.isEnd())
return q.getNext();
for (int index = 0; index < lq.getBodyCount(); index++) {
Interview b = lq.getBody(index);
if (b.path == null) {
b.path = new Path();
}
else {
b.path.clear();
}
b.path.addQuestion(b.firstQuestion);
b.caller = null;
b.predictPath(b.firstQuestion);
}
Interview lqBody = lq.getSelectedBody();
Question lqOther = lq.getOther();
if (lqBody == null)
return lqOther.getNext();
else {
Interview lqInt = lq.getInterview();
return new InterviewQuestion(lqInt, lqBody, lqOther);
}
}
return q.getNext();
}
/**
* Get an entry from the resource bundle.
* If the resource cannot be found, a message is printed to the console
* and the result will be a string containing the method parameters.
* @param key the name of the entry to be returned
* {@link java.text.MessageFormat#format}
* @return the formatted string
*/
private String getI18NString(String key) {
return getI18NString(key, empty);
}
private static final Object[] empty = { };
/**
* Get an entry from the resource bundle.
* If the resource cannot be found, a message is printed to the console
* and the result will be a string containing the method parameters.
* @param key the name of the entry to be returned
* @param arg an argument to be formatted into the result using
* {@link java.text.MessageFormat#format}
* @return the formatted string
*/
private String getI18NString(String key, Object arg) {
return getI18NString(key, new Object[] { arg });
}
/**
* Get an entry from the resource bundle.
* If the resource cannot be found, a message is printed to the console
* and the result will be a string containing the method parameters.
* @param key the name of the entry to be returned
* @param args an array of arguments to be formatted into the result using
* {@link java.text.MessageFormat#format}
* @return the formatted string
*/
private String getI18NString(String key, Object[] args) {
try {
ResourceBundle b = getResourceBundle();
if (b != null)
return MessageFormat.format(b.getString(key), args);
}
catch (MissingResourceException e) {
// should msgs like this be i18n and optional?
System.err.println("WARNING: missing resource: " + key);
}
StringBuffer sb = new StringBuffer(key);
for (int i = 0; i < args.length; i++) {
sb.append('\n');
sb.append(Arrays.toString(args));
}
return sb.toString();
}
/**
* Get an entry from the resource bundle.
* The parent and other ancestors bundles will be checked first before
* this interview's bundle, allowing the root interview a chance to override
* the default value provided by this interview.
* @param key the name of the entry to be returned
* @return the value of the resource, or null if not found
*/
protected String getResourceString(String key) {
return getResourceString(key, true);
}
/**
* Get an entry from the resource bundle. If checkAncestorsFirst is true,
* then the parent and other ancestors bundles will be checked first before
* this interview's bundle, allowing the root interview a chance to override
* the default value provided by this interview. Otherwise, the parent bundles
* will only be checked if this bundle does not provide a value.
* @param key the name of the entry to be returned
* @param checkAncestorsFirst whether to recursively call this method on the
* parent (if any) before checking this bundle, or only afterwards, if this
* bundle does not provide a value
* @return the value of the resource, or null if not found
*/
protected String getResourceString(String key, boolean checkAncestorsFirst) {
try {
String s = null;
if (checkAncestorsFirst) {
if (parent != null)
s = parent.getResourceString(key, checkAncestorsFirst);
if (s == null) {
ResourceBundle b = getResourceBundle();
if (b != null)
s = b.getString(key);
}
}
else {
ResourceBundle b = getResourceBundle();
if (b != null)
s = b.getString(key);
if (s == null && parent != null)
s = parent.getResourceString(key, checkAncestorsFirst);
}
return s;
}
catch (MissingResourceException e) {
return null;
}
}
// can change this to "assert(b)" in JDK 1.5
private static final void ASSERT(boolean b) {
if (!b)
throw new IllegalStateException();
}
/**
* The parent interview, if applicable; otherwise null.
*/
private final Interview parent;
/**
* The root (most parent) interview; never null
*/
private final Interview root;
private String baseTag; // tag relative to parent
private String tag; // full tag: parent tag + baseTag
/**
* A descriptive title for the interview.
*/
private String title;
/**
* The first question of the interview.
*/
private Question firstQuestion;
/**
* Any child interviews.
*/
private Vector children = new Vector<>();
/**
* An index of the questions in this interview.
*/
private Map allQuestions = new LinkedHashMap<>();
/**
* The default image for questions in the interview.
*/
private URL defaultImage;
private Object helpSet;
// object to create HelpSet and Help ID
// in batch mode, this factory should return stubs.
protected final static HelpSetFactory helpSetFactory = createHelpFactory();
private String bundleName;
private ResourceBundle bundle;
private Path path;
private Path rawPath;
private ArrayList hiddenPath;
private int currIndex;
private InterviewQuestion caller;
private boolean updateEnabled;
private boolean edited;
private Map> allMarkers;
private Map extraValues; // used in top-level interview only
private Map templateValues;
private int semantics = SEMANTIC_PRE_32;
static final ResourceBundle i18n = ResourceBundle.getBundle("com.sun.interview.i18n");
/**
* Where necessary, the harness interview should behave as it did before the
* 3.2 release. This does not control every single possible change in
* behavior, but does control certain behaviors which may cause problems with
* interview code written against an earlier version of the harness.
* @see #setInterviewSemantics
*/
public static final int SEMANTIC_PRE_32 = 0;
/**
*
* Where necessary, the harness interview should behave as it did for the
* 3.2 release. This does not control every single possible change in
* behavior, but does control certain behaviors which may cause problems with
* interview code written against an earlier version of the harness.
* @see #setInterviewSemantics
*/
public static final int SEMANTIC_VERSION_32 = 1;
/**
*
* Where necessary, the harness interview should behave as it did for the
* 4.3 release. This does not control every single possible change in
* behavior, but does control certain behaviors which may cause problems with
* interview code written against an earlier version of the harness.
*
*
* @see #setInterviewSemantics
*/
public static final int SEMANTIC_VERSION_43 = 2;
/**
*
* Where necessary, the harness interview should behave as it did for the
* 4.3 release. This does not control every single possible change in
* behavior, but does control certain behaviors which may cause problems with
* interview code written against an earlier version of the harness.
*
*
* @see #setInterviewSemantics
*/
public static final int SEMANTIC_VERSION_50 = 3;
/**
* The highest version number currently in use. Note that the compiler
* will probably inline this during compilation, so you will be locked at
* the version which you compile against. This is probably a useful
* behavior in this case.
* @see #setInterviewSemantics
*/
public static final int SEMANTIC_MAX_VERSION = 3;
static class Path {
void addQuestion(Question q) {
if (questions == null)
questions = new Question[10];
else if (numQuestions == questions.length) {
Question[] newQuestions = new Question[2 * questions.length];
System.arraycopy(questions, 0, newQuestions, 0, questions.length);
questions = newQuestions;
}
questions[numQuestions++] = q;
}
Question questionAt(int index) throws ArrayIndexOutOfBoundsException {
if (index < 0 || index >= numQuestions)
throw new ArrayIndexOutOfBoundsException();
return questions[index];
}
Question lastQuestion() {
return questionAt(numQuestions - 1);
}
// return shallow copy
Question[] getQuestions() {
if (questions == null)
return null;
Question[] copy = new Question[questions.length];
System.arraycopy(questions, 0, copy, 0, questions.length);
return copy;
}
int indexOf(Interview interview) {
for (int index = 0; index < numQuestions; index++) {
Question q = questions[index];
if (q instanceof InterviewQuestion
&& ((InterviewQuestion) q).getTargetInterview() == interview)
return index;
}
return -1;
}
int indexOf(Question target) {
for (int index = 0; index < numQuestions; index++) {
Question q = questions[index];
if (q == target)
return index;
}
return -1;
}
int size() {
return numQuestions;
}
void setSize(int newSize) {
// expected case is only to shrink size, so questions != null && newSize < questions.length
if (questions != null) {
if (newSize > questions.length) {
Question[] newQuestions = new Question[newSize];
System.arraycopy(questions, 0, newQuestions, 0, questions.length);
questions = newQuestions;
}
for (int i = newSize; i < numQuestions; i++)
questions[i] = null;
}
else if (newSize > 0)
questions = new Question[newSize];
numQuestions = newSize;
}
void clear() {
for (int i = 0; i < numQuestions; i++)
questions[i] = null;
numQuestions = 0;
}
private Question[] questions;
private int numQuestions;
}
protected final static String QUESTION = "QUESTION";
protected final static String INTERVIEW = "INTERVIEW";
protected final static String LOCALE = "LOCALE";
//protected final static String CHECKSUM = "CHECKSUM";
protected final static String MARKERS = "MARKERS";
protected final static String MARKERS_PREF = "MARKERS.";
protected static final String EXTERNAL_PREF = "EXTERNAL.";
protected static final String TEMPLATE_PREF = "TEMPLATE.";
}