AnswerableProblem

java.lang.Object
- org.assistments.domain.content.tutor.Persistable
- - org.assistments.domain.content.tutor.Content
  - - org.assistments.domain.content.tutor.AssessmentContent
    - - org.assistments.domain.content.tutor.Problem
      - org.assistments.domain.content.tutor.AnswerableProblem<P,A,V,R>

Type Parameters:

P - is for answer Part. A subclass of AnswerValuePart representing a single part of a teacher's answer value or a student's response value.
A - is for Answer. A subclass of Answer representing a teacher-provided answer for a concrete problem type.
Each Answer subclass depends on:
- P — AnswerValuePart subclass
- V — TeacherAnswerValue subclass
- R — StudentResponseValue subclass
V - is for answer Value. A subclass of TeacherAnswerValue representing a correct or incorrect teacher-provided answer value.
Each TeacherAnswerValue subclass depends on:
- P — AnswerValuePart subclass
- R — StudentResponseValue subclass
R - is for student Response. A subclass of StudentResponseValue representing a student's response to a problem.
Each TeacherAnswerValue subclass depends on:
- P — AnswerValuePart subclass
All Implemented Interfaces:

HasUID, IsPersistable, SelfValidating

Direct Known Subclasses:

ChooseNProblem, ExternalProblem, FillInProblem, FillInUnitsProblem, PlusMinusRangeProblem, RangeProblem
```
public abstract class AnswerableProblem<P extends AnswerValuePart,A extends Answer<P,V,R>,V extends TeacherAnswerValue<P,R>,R extends StudentResponseValue<P>>
extends Problem
```
AnswerableProblem is the base class for problems with answers that can be identified, or evaluated, as correct or incorrect.
Overview
An AnswerableProblem is composed of a question and a collection of one or more answers.
Each concrete AnswerableProblem subclass implements a distinct problem type. The problem type inherently dictates:
- Whether the problem can have multiple correct answers.
  In most, but not all subclasses, the problem creator - that is the person that wrote the problem and its answers - specifies whether each answer is a correct or incorrect choice.
  For example, the question "What is the sum of: 1/2 + 1/2 +1/2?" could have the following answers all of which might be set as correct: 1.5; 3/2; 1 1/2.
- How to determine whether a student's response is correct.
- How its answers are displayed.
  For example: A multiple choice problem displays each possible answer (most likely) as a radio button while a fill in problem provides (most likely) a text box for the student's response.
- How many data parts are in an answer and how many data parts are in a student's response.
  For example: The range problem type has an answer made up of two data parts: a lower- and upper-limit. The student's response consists of a single data part (and the response is correct if it falls within the answer's limits).
The following diagram summarizes the base classes needed to subclass AnswerableProblem and create a concrete problem type:
Briefly:
1. Each AnswerableProblem contains a list of Answers.
  As noted earlier, each answer can be marked as correct or incorrect when that semantic is relevant.
2. Each Answer, developed by a teacher or other content creator, stores its value in a TeacherAnswerValue instance (which extends AnswerValue).
3. The TeacherAnswerValue keeps a List of one or more AnswerValueParts.
  The semantics of the AnswerableProblem subclass determines the number of parts to an answer. In the above example (What is the sum of 1/2 + 1/2 +1/2?), each answer value is composed of a single part. Other problem types can have more than one part to each answer value. For instance, a problem type dealing with x,y coordinates has two parts to every answer value. ASSISTments uses an AnswerValuePart to store each part of an answer's value.
4. Each AnswerValuePart is composed of the value itself, represented as a String, and an AnswerEvalType directing how ASSISTments evaluates the string value.
  For example: If the concrete problem class specifies its answer parts are of type AnswerEvalType.STRING, ASSISTments evaluates the student's response to the question by comparing String values (the student's response and the answer's value).
  For a problem type with multiple value part answers, you are free to assign each value part a different evaluation type. A fill in problem with units provides an example: The first part, the value a student calculates to answer the question, might be evaluated as an AnswerEvalType.NUMERIC, while the second part, the value's units, would be evaluated as a STRING value. The enum AnswerEvalType lists the supported evaluation types.
5. Finally, each concrete problem type requires a corresponding response value object to hold a student's response to the problem's question. The concrete response value extends StudentResponseValue (which extends AnswerValue).
  In many cases a response value contains the same number of answer value parts as that problem's TeacherAnswerValue subclass. For example a fill-in problem's response class expects a single value part (to be matched against the fill-in problem's answer list).
  However, it is possible that the StudentResponseValue part count differs from the TeacherAnswerValue part count. For instance, the answer value for a range problem consists of two parts, a lower- and an upper-limit value. Range problems are constructed such that ASSISTment's looks to see if the student's response, a single value, falls between the those two limits. In this case, you define the range problem's response value object to contain a single value part.
Concrete Example
Using FillInProblem as an example, a new concrete problem type requires the following concrete classes:
- A concrete subclass of AnswerableProblem.
  Your subclass must call registerProblemTypeAttributes() in a static initializer block.
  For example: FillInProblem
- A concrete subclass of Answer.
  For example: FillInAnswer
- A concrete subclass of TeacherAnswerValue to represent answer values provided by content builders.
  For example: FillInAnswerValue
- A concrete subclass of StudentResponseValue to represent a student's response to the problem's question.
  For example: FillInResponseValue
- A concrete subclass of AnswerValuePart to represent a single part of an answer's value.
  For example: FillInAnswerValuePart
Defining Correctness
Each problem type specifies it's own logic for determining whether a student's response to a problem is correct.
To assist, AnswerableProblem provides a default semantic for checking the correctness of a student's response. The response is declared correct if both these conditions are true:
1. The student's response matches one of the answers, and
2. That matching answer was marked by the content creator as a correct answer
To accomplish that, each concrete problem type must implement:

AnswerableProblem.isCorrect(StudentResponseValue) and
For an AnswerableProblem subclass to easily implement the default behavior (of checking for a match and correctness), this package provides the methods:
- AnswerableProblem.isCorrectDefault(StudentResponseValue) and
- Answer#isMatchDefault(StudentResponseValue)
- TeacherAnswerValue#isMatchDefault(StudentResponseValue)
- AnswerValuePart#isMatchDefault(AnswerValuePart)
For an AnswerableProblem where both the TeacherAnswerValue and the StudentResponseValue contain the same number and types of value parts, then:
- the AnswerableProblem subclass can implement AnswerableProblem.isCorrect(StudentResponseValue) by calling AnswerableProblem.isCorrectDefault(StudentResponseValue), and
- the Answer subclass can implement Answer#isMatch(StudentResponseValue) by calling Answer#isMatchDefault(StudentResponseValue), and
- the TeacherAnswerValue subclass can implement TeacherAnswerValue#isMatch(StudentResponseValue) by calling TeacherAnswerValue#isMatchDefault(StudentResponseValue), and
- the AnswerValuePart subclass can implement AnswerValuePart#isMatch(AnswerValuePart) by calling AnswerValuePart#isMatchDefault(AnswerValuePart)
For some subclass problem types, calling isCorrectDefault() is not suitable and those subclasses may need to provide their own full implementations for isCorrect() and/or isMatch().
The SortingProblem provides an example of a problem type where declaring each answer as correct or incorrect is meaningless. In SortingProblem, the "answers" represent the values to be ordered by a student. SortingProblem compares the ordering specified by the student to the correct ordering of the displayed values (the "answers"). Accordingly, SortingProblem completely implements that semantic in isCorrect() and has no need to call isMatch().
Building a New Problem Type

To actually implement a new problem type, it is best to proceed starting at the answer value part level and working your way up to the new problem class itself.
Using a new problem type, say the "Uber Problem" type, the following steps outline how to implement an UberProblem class based on AnswerableProblem:
1. Create the UberProblemAnswerValuePart class by extending AnswerValuePart
  Determine how to implement the abstract method AnswerValuePart#isMatch(AnswerValuePart). There are three possibilities:
  - If AnswerValuePart#isMatchDefault(AnswerValuePart) provides the proper semantics, implement isMatch() to call isMatchDefault().
  - If your problem type requires unique logic, implement isMatch() to execute that logic.
  - If processing of the student response (against teacher-provided answers) takes place exclusively, for example, in AnswerableProblem.isCorrect(StudentResponseValue), implement the required AnswerValuePart#isMatch(AnswerValuePart) method to call the static method Answer.preventIsMatch(String). That reflects that you never expect code to call isMatch().
2. Create the UberProblemResponseValue class by extending StudentResponseValue. Generally speaking subclasses of StudentResponseValue are thin wrapper classes. They serve to help completely define a problem type (having a problem, teacher answer, student response, etc).
3. Create the UberProblemAnswerValue class by extending TeacherAnswerValue.
  Parallel to what was one for UberProblemAnswerValuePart.isMatch(), determine how to implement the abstract method TeacherAnswerValue#isMatch(StudentResponseValue). Again, there are three possibilities:
  - If TeacherAnswerValue#isMatchDefault(StudentResponseValue) provides the proper semantics, implement isMatch() to call isMatchDefault().
  - If your problem type requires unique logic, implement isMatch() to execute that logic.
  - If processing of the student response (against teacher-provided answers) takes place exclusively, for example, in * AnswerableProblem.isCorrect(StudentResponseValue), implement the required TeacherAnswerValue#isMatch(StudentResponseValue) method to call the static method Answer.preventIsMatch(String). That reflects that you never expect code to call isMatch().
4. Create the UberProblemAnswer class by extending Answer.
  Define or create:
  - private static final String className = UberProblemAnswer.class.getName();
  - A constructor that takes only a UID and calls the super class constructor with the just defined className and the UID.
  - Implementation for the abstract method Answer#isMatch(StudentResponseValue)
    Follow the same approach described above (of three possibilities) for implementing TeacherAnswerValue#isMatch(StudentResponseValue) and AnswerValuePart#isMatch(AnswerValuePart).
5. Create the UberProblem class by extending AnswerableProblem.
  Define or create:
  - private static final String className = UberProblem.class.getName();
  - A static initializer to call AnswerableProblem.registerProblemTypeAttributes().
  - A constructor that takes only a UID and calls the super class constructor with the just defined className and the UID.
  - Implement: addAnswer(String, boolean, AnswerValuePart...)
  - Implement a second, convenience version, of addAnswer() so that callers do not really need to know about creating their own AnswerValuePart arguments. In cases where a problem type allows for limited answer and response evaluation types, you can shield callers from complexity.
  - Implement: makeResponse(String...)
Some of the above superclasses contain abstract methods that your corresponding subclass must implement. Others contain methods that your subclass will need to override.
See Also:

SubmittableProblem

Field Summary

Fields
Modifier and Type	Field and Description
`protected static java.util.List<java.lang.String>`	`answerableClasses`
`protected java.util.Map<java.lang.String,java.lang.String>`	`probProperties`

Fields inherited from class org.assistments.domain.content.tutor.Problem
defaultResponseDescription

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AnswerableProblem(java.lang.String classType, java.lang.String uid)` Constructor
`protected`	`AnswerableProblem(java.lang.String classType, java.lang.String uid, java.lang.String name, java.lang.String description)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAnswer(A answer)` Adds an answer to the list of answers.
`protected abstract A`	`addAnswer(java.lang.String uid, boolean isCorrect, P... valueParts)` Given a list of value parts, returns a subclass instance of an `Answer` containing those values.
`void`	`addProperty(java.lang.String key, java.lang.String value)`
`A`	`getAnswer(int index)` Returns a particular answer.
`int`	`getAnswerCount()` Returns the current number of answers for this problem.
`AnswerEvalType`	`getAnswerEvalType(int i)` Returns the evaluation type for the specified value part in this problem's answers.
`java.util.List<AnswerEvalType>`	`getAnswerEvalTypes()` Returns the list of evaluation types for each value part in this problem's answers.
`java.util.List<A>`	`getAnswers()` Returns the answers for this problem as they were ordered by the problem creator.
`java.util.List<A>`	`getAnswers(boolean enableRandom)` Returns the answers for this problem.
`java.util.List<P>`	`getAnswerValuePartsList()` Returns, in a single list, the answer value parts from all of the answers to this problem.
`A`	`getCorrectAnswer()` Returns the correct `Answer`, if any, matched to the student's response.
`AnswerableProblemAttributes`	`getProblemTypeAttributes()` Returns the problem type properties for this instance's class type.
`static AnswerableProblemAttributes`	`getProblemTypeAttributes(java.lang.String classType)` Returns a problem type's properties.
`java.util.Map<java.lang.String,java.lang.String>`	`getProperties()`
`java.lang.String`	`getProperty(java.lang.String key)`
`AnswerEvalType`	`getResponseEvalType(int i)` Returns the evaluation type for the specified value part in this problem's response.
`java.util.List<AnswerEvalType>`	`getResponseEvalTypes()` Returns the list of evaluation types for each value part in this problem's response.
`java.lang.String`	`getUnscrambledAnswerIndexes(java.lang.String responseIndexes)` Returns a space-separated list of numbers where each number represents an index into this problem's original, non-randomized, answer list.
`protected java.lang.String`	`getUnscrambledAnswerIndexes(java.lang.String responseIndexes, boolean sort)` See `getUnscrambledAnswerIndexes(String)` for the method description.
`A`	`getWrongAnswer()` Returns the wrong `Answer`, if any, matched to the student's response.
`boolean`	`isAllowedAnswerEvalType(AnswerEvalType evalType)` Returns whether an evaluation type is allowed for this problem.
`boolean`	`isAllowedResponseEvalType(AnswerEvalType evalType)` Returns whether an evaluation type is allowed for responses to this problem.
`static boolean`	`isAnswerable(java.lang.String s)`
`boolean`	`isCorrect(R response)` A convenience method for isCorrect that uses the problem's properties as arguments
`abstract boolean`	`isCorrect(R response, java.util.Map<java.lang.String,java.lang.String> args)` Determines whether the submitted response to this question is correct.
`boolean`	`isCorrectDefault(R response, java.util.Map<java.lang.String,java.lang.String> args)` Provides a default implementation for use by `isCorrect(StudentResponseValue)`.
`boolean`	`isScrambleAnswers()` Returns whether answers are to be returned in a random order.
`protected abstract R`	`makeResponse(java.lang.String... responseParts)` For the given values entered, returns an `AnswerValue` containing those parts.
`protected static void`	`registerProblemTypeAttributes(java.lang.String problemClassType, java.lang.String answerClassType, java.lang.String answerValueClassType, java.lang.String responseValueClassType, int maxAnswers, int answerValuePartsCount, int responseValuePartsCount, java.util.List<AnswerEvalType> allowedAnswerEvalTypes, java.util.List<AnswerEvalType> allowedRepsonseEvalTypes)` Called by an `AnswerableProblem` subclass to register properties about that problem type represented by that subclass.
`void`	`setAnswerEvalTypes(AnswerEvalType... evalTypes)` Specifies the evaluation type for each value part in this problem answers.
`void`	`setAnswerEvalTypes(AnswerEvalType evalType)` Sets all answer value parts to the same, single evaluation type.
`void`	`setAnswers(java.util.List<A> answers)` Specifies a set of answers to this problem.
`void`	`setCorrectAnswer(A answer)` Records the known correct answer that matches a student's response.
`void`	`setProperties(java.util.Map<java.lang.String,java.lang.String> properties)`
`void`	`setResponseEvalTypes(AnswerEvalType... evalTypes)` Specifies the evaluation type for each value part in this problem response.
`void`	`setResponseEvalTypes(AnswerEvalType evalType)` Sets all response value parts to the same, single evaluation type.
`void`	`setScrambleAnswers(boolean scrambleAnswers)` Specifies whether answers are to be displayed in a random order.
`void`	`setWrongAnswer(A answer)` Records the known wrong answer that matches a student's response.
`void`	`validate()` Check this object's data for inconsistencies Subclasses must (by informal contract) implement this method!

Methods inherited from class org.assistments.domain.content.tutor.Problem
getQuestion, getResponseTypeDescription, setQuestion

Methods inherited from class org.assistments.domain.content.tutor.AssessmentContent
initializeContent

Methods inherited from class org.assistments.domain.content.tutor.Content
getDescription, getName, setDescription, setName

Methods inherited from class org.assistments.domain.content.tutor.Persistable
createKey, createKey, equals, extractType, extractUID, getKey, getShortKey, getShortKey, getType, getUID, getValidatorUtilities, setValidatorUtilities, toString, validateKey

Methods inherited from class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - answerableClasses
```
protected static java.util.List<java.lang.String> answerableClasses
```
  - probProperties
```
protected java.util.Map<java.lang.String,java.lang.String> probProperties
```
- Constructor Detail
  - AnswerableProblem
```
protected AnswerableProblem(java.lang.String classType,
                            java.lang.String uid)
```
    Constructor
    
    Parameters:
    
    classType - The fully-specified class name of the concrete subclass. This is equivalent to the String returned from calling <Class>.class.getName()
    
    uid - A unique identifier for this object instance.
  - AnswerableProblem
```
protected AnswerableProblem(java.lang.String classType,
                            java.lang.String uid,
                            java.lang.String name,
                            java.lang.String description)
```
- Method Detail
  - addAnswer
```
protected abstract A addAnswer(java.lang.String uid,
                               boolean isCorrect,
                               P... valueParts)
```
    Given a list of value parts, returns a subclass instance of an Answer containing those values.
    It is highly recommended that each AnswerableProblem subclass implements a custom, public version of the addAnswer(...) method which hides from the calling code the variable arguments AnswerValuePart... valueParts.
    For example, a fill in problem would implement:
    public FillInAnswer addAnswer(String uid, boolean isCorrect, String value)
    The implementation of this abstract method would be responsible for obtaining the evaluation type, and the subsequent creation of an AnswerValuePart.
    
    Parameters:
    
    uid - Unique identifier for this answer
    
    valueParts - The value parts comprising this answer.
    
    Returns:
    
    For informational purposes, the newly create Answer
    
    See Also:
    
    getAnswerEvalTypes(), AnswerValuePart
  - makeResponse
```
protected abstract R makeResponse(java.lang.String... responseParts)
```
    For the given values entered, returns an AnswerValue containing those parts.
    
    Parameters:
    
    responseParts - One or more values entered in response to a question. For example, a fill-in problem expects a single response string. An ordered pair problem expects two response strings.
    
    Returns:
    
    A subclass of AnswerValue. By convention the subclass should be named: <problem name>StudentResponseValue
  - registerProblemTypeAttributes
```
protected static void registerProblemTypeAttributes(java.lang.String problemClassType,
                                                    java.lang.String answerClassType,
                                                    java.lang.String answerValueClassType,
                                                    java.lang.String responseValueClassType,
                                                    int maxAnswers,
                                                    int answerValuePartsCount,
                                                    int responseValuePartsCount,
                                                    java.util.List<AnswerEvalType> allowedAnswerEvalTypes,
                                                    java.util.List<AnswerEvalType> allowedRepsonseEvalTypes)
                                             throws java.lang.IllegalStateException
```
    Called by an AnswerableProblem subclass to register properties about that problem type represented by that subclass.
    
    Parameters:
    
    problemClassType - The fully specified AnswerableProblem subclass class name.
    
    answerValueClassType - The fully specified AnswerValue subclass class name implementing problemClassType's answer values.
    
    responseValueClassType - The fully specified AnswerValue subclass class name implementing problemClassType's student response values.
    
    maxAnswers - Maximum number of answers allowed per problem instance. 0 signals to allow an unlimited number of answers.
    
    answerValuePartsCount - The number of value parts (AnswerValuePart) making up an answer for answerValueClassType.
    
    responseValuePartsCount - The number of value parts (AnswerValuePart) making up an answer for responseValueClassType.
    
    allowedAnswerEvalTypes - The list of evaluation types allowed in each answer's value parts.
    
    allowedRepsonseEvalTypes - The list of evaluation types allowed in each response's value parts.
    
    Throws:
    
    java.lang.IllegalStateException - if the subclass has already registered with different attribute values
    
    See Also:
    
    AnswerValue, AnswerValuePart, AnswerEvalType.getSupportedEvalTypes()
  - getProblemTypeAttributes
```
public static AnswerableProblemAttributes getProblemTypeAttributes(java.lang.String classType)
                                                            throws java.lang.IllegalStateException
```
    Returns a problem type's properties.
    
    Parameters:
    
    classType - The fully specified AnswerableProblem subclass class name of interest.
    
    Throws:
    
    java.lang.IllegalStateException - If classType was not previously registered.
    
    java.lang.IllegalStateException - If the subclass failed to call registerProblemTypeAttributes(String, String, String, String, int, int, int, List, List)
    
    See Also:
    
    registerProblemTypeAttributes(String, String, String, String, int, int, int, List, List), getProblemTypeAttributes()
  - getUnscrambledAnswerIndexes
```
public java.lang.String getUnscrambledAnswerIndexes(java.lang.String responseIndexes)
```
    Returns a space-separated list of numbers where each number represents an index into this problem's original, non-randomized, answer list.
    Certain problem types display multiple possible answers. This includes problem types that require a student to choose N correct answers and those that require a student to sort a list of displayed values.
    For those problem types, ASSISTments determines correctness by comparing the answer index numbers selected by the student to those of the displayed answers.
    For logging purposes ASSISTments needs to record the student's response (i.e. the index numbers) as if the answers had not be displayed in a random order.
    Calling getUnscrambledAnswerIndexes() returns non-random answer index numbers corresponding to the student's response.
    
    Parameters:
    
    responseIndexes - A space-separated list of answer indexes. For example, if the problem displayed 3 answers and the student selected the first and the third, responseIndexes would contain, as a string: 0 2
    
    Returns:
    
    a space-separated list of numbers corresponding to this problems's answers.
    
    See Also:
    
    Util.scrambleList(List), getAnswers(boolean)
  - getUnscrambledAnswerIndexes
```
protected java.lang.String getUnscrambledAnswerIndexes(java.lang.String responseIndexes,
                                                       boolean sort)
```
    See getUnscrambledAnswerIndexes(String) for the method description.
    This version of the method is intended for use by JUnit tests only.
    
    Parameters:
    
    responseIndexes - A space-separated list of answer indexes. For example, if the problem displayed 3 answers and the student selected the first and the third, responseIndexes would contain, as a string: 0 2
    
    sort - true to numerically sort the indexes in the return value; false to leave them unsorted.
    
    Returns:
    
    a space-separated list of numbers corresponding to this problems's answers.
    
    See Also:
    
    getUnscrambledAnswerIndexes(String), Util.scrambleList(List), getAnswers(boolean)
  - getProblemTypeAttributes
```
public AnswerableProblemAttributes getProblemTypeAttributes()
                                                     throws java.lang.IllegalStateException
```
    Returns the problem type properties for this instance's class type.
    
    Throws:
    
    java.lang.IllegalStateException - @throws IllegalStateException If this instance's class type was not previously registered.
    
    See Also:
    
    registerProblemTypeAttributes(String, String, String, String, int, int, int, List, List), getProblemTypeAttributes(String)
  - isScrambleAnswers
```
public boolean isScrambleAnswers()
```
    Returns whether answers are to be returned in a random order.
    
    See Also:
    
    setScrambleAnswers(boolean), getAnswers(boolean)
  - setScrambleAnswers
```
public void setScrambleAnswers(boolean scrambleAnswers)
```
    Specifies whether answers are to be displayed in a random order.
    
    Parameters:
    
    scrambleAnswers - true to return answers in a random order.
    
    See Also:
    
    getAnswers(boolean)
  - setAnswerEvalTypes
```
public void setAnswerEvalTypes(AnswerEvalType evalType)
```
    Sets all answer value parts to the same, single evaluation type.
    For an answer with a single value part, specifies that part's evaluation type. For an answer with a multiple value parts, specifies a single evaluation type for all the value parts.
    This is a convenience method to handle the case when you want all of a problem's answer value parts to use same evaluation type - or if there is only one value part per answer. Using this method allows you to pass a single AnswerEvalType rather than having to construct the list parameter needed for the other versions of the setEvalTypesPerAnswer() method.
    
    Parameters:
    
    evalType - The evaluation type to apply to the answer's value part(s).
    
    See Also:
    
    setAnswerEvalTypes(AnswerEvalType...), getAnswerEvalTypes(), getAnswerEvalType(int)
  - setAnswerEvalTypes
```
public void setAnswerEvalTypes(AnswerEvalType... evalTypes)
                        throws java.lang.IllegalArgumentException
```
    Specifies the evaluation type for each value part in this problem answers.
    
    Parameters:
    
    evalTypes - The list of evaluation types in the exact order you want them applied to each answer value part.
    For example: For a problem type with two value parts, the first a number, the second a string, your call would be:
    setAnswerEvalTypes(AnswerEvalType.NUMERIC, AnswerEvalType.STRING)
    or you could set-up and pass a 2-element AnswerEvalType array with the [0] contains AnswerEvalType.NUMERIC and the [1] contains AnswerEvalType.STRING
    
    Throws:
    
    java.lang.IllegalArgumentException - if the number of evalTypes is different than the expected number for answers of this problem type.
    
    See Also:
    
    setAnswerEvalTypes(AnswerEvalType), getAnswerEvalTypes(), getAnswerEvalType(int)
  - getAnswerEvalTypes
```
public java.util.List<AnswerEvalType> getAnswerEvalTypes()
```
    Returns the list of evaluation types for each value part in this problem's answers.
    
    See Also:
    
    getAnswerEvalType(int), setAnswerEvalTypes(AnswerEvalType...), setAnswerEvalTypes(AnswerEvalType)
  - getAnswerEvalType
```
public AnswerEvalType getAnswerEvalType(int i)
                                 throws java.lang.IllegalArgumentException
```
    Returns the evaluation type for the specified value part in this problem's answers.
    
    Parameters:
    
    i - index of the desired evaluation type.
    
    Throws:
    
    java.lang.IllegalArgumentException - If the value of i exceeds the number of value parts per answer for this problem type.
    
    See Also:
    
    getAnswerEvalTypes(), setAnswerEvalTypes(AnswerEvalType...), setAnswerEvalTypes(AnswerEvalType)
  - isAllowedAnswerEvalType
```
public boolean isAllowedAnswerEvalType(AnswerEvalType evalType)
```
    Returns whether an evaluation type is allowed for this problem.
    
    Parameters:
    
    evalType - Evaluation type to check
    
    Returns:
    
    true if evalType is valid for this problem's answers; otherwise false
    
    See Also:
    
    AnswerEvalType, registerProblemTypeAttributes(String, String, String, String, int, int, int, List, List)
  - setResponseEvalTypes
```
public void setResponseEvalTypes(AnswerEvalType evalType)
```
    Sets all response value parts to the same, single evaluation type.
    For a response with a single value part, specifies that part's evaluation type. For a response with a multiple value parts, specifies a single evaluation type for all the value parts.
    This is a convenience method to handle the case when you want all of a problem's response value parts to use same evaluation type - or if there is only one value part per response. Using this method allows you to pass a single AnswerEvalType rather than having to construct the list parameter needed for the other versions of the setEvalTypesPerAnswer() method.
    
    Parameters:
    
    evalType - The evaluation type to apply to the response's value part(s).
    
    See Also:
    
    setResponseEvalTypes(AnswerEvalType...), getResponseEvalTypes(), getResponseEvalType(int)
  - setResponseEvalTypes
```
public void setResponseEvalTypes(AnswerEvalType... evalTypes)
                          throws java.lang.IllegalArgumentException
```
    Specifies the evaluation type for each value part in this problem response.
    
    Parameters:
    
    evalTypes - The list of evaluation types in the exact order you want them applied to each response value part.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the number of evalTypes is different than the expected number for responses of this problem type.
    
    See Also:
    
    setResponseEvalTypes(AnswerEvalType), getResponseEvalTypes(), getResponseEvalType(int)
  - getResponseEvalTypes
```
public java.util.List<AnswerEvalType> getResponseEvalTypes()
```
    Returns the list of evaluation types for each value part in this problem's response.
    
    See Also:
    
    getResponseEvalType(int), setResponseEvalTypes(AnswerEvalType...), setResponseEvalTypes(AnswerEvalType)
  - getResponseEvalType
```
public AnswerEvalType getResponseEvalType(int i)
                                   throws java.lang.IllegalArgumentException
```
    Returns the evaluation type for the specified value part in this problem's response.
    
    Parameters:
    
    i - index of the desired evaluation type.
    
    Throws:
    
    java.lang.IllegalArgumentException - If the value of i exceeds the number of value parts per response for this problem type.
    
    See Also:
    
    getResponseEvalTypes(), setResponseEvalTypes(AnswerEvalType...), setResponseEvalTypes(AnswerEvalType)
  - isAllowedResponseEvalType
```
public boolean isAllowedResponseEvalType(AnswerEvalType evalType)
```
    Returns whether an evaluation type is allowed for responses to this problem.
    
    Parameters:
    
    evalType - Evaluation type to check
    
    Returns:
    
    true if evalType is valid for this problem's responses; otherwise false
    
    See Also:
    
    AnswerEvalType, registerProblemTypeAttributes(String, String, String, String, int, int, int, List, List)
  - getAnswerCount
```
public int getAnswerCount()
```
    Returns the current number of answers for this problem.
  - getAnswers
```
public java.util.List<A> getAnswers(boolean enableRandom)
```
    Returns the answers for this problem.
    Parameters:
    enableRandom - Specifies whether to apply or ignore this problem's setting for randomly ordering answers as follows:
    
    If true, getAnswers() returns the answers based on the setScrambleAnswers(boolean) setting. This means that if isScrambleAnswers() returns false, getAnswers returns the answers in the order they were entered for this problem. That is to say: when isScrambleAnswers() returns false, the value of enableRandom is irrelevant.
    
    If false, getAnswers() ignores the setScrambleAnswers(boolean) setting and returns the answers in the order they were entered for this problem.
    pay attention to the answers list be returned
    See Also:
    
    getAnswers(), getAnswer(int), setAnswers(List), addAnswer(Answer), addAnswer(String, boolean, AnswerValuePart...)
  - getAnswers
```
public java.util.List<A> getAnswers()
```
    Returns the answers for this problem as they were ordered by the problem creator.
    
    See Also:
    
    getAnswers(boolean), getAnswer(int)
  - getAnswer
```
public A getAnswer(int index)
```
    Returns a particular answer.
    
    Parameters:
    
    index - Index of the answer to return.
  - setAnswers
```
public void setAnswers(java.util.List<A> answers)
                throws java.lang.IllegalArgumentException
```
    Specifies a set of answers to this problem. Replaces any existing answers.
    
    Parameters:
    
    answers - Answers to save.
    
    Throws:
    
    java.lang.IllegalArgumentException
    
    See Also:
    
    addAnswer(Answer), addAnswer(String, boolean, AnswerValuePart...), getAnswers(boolean)
  - addAnswer
```
public void addAnswer(A answer)
               throws java.lang.IllegalArgumentException
```
    Adds an answer to the list of answers.
    
    Parameters:
    
    answer - Answer to add
    
    Throws:
    
    java.lang.IllegalArgumentException - If adding answer would exceed the maximum answers allowed for this problem type.
    
    See Also:
    
    addAnswer(String, boolean, AnswerValuePart...), setAnswers(List), getAnswers(boolean), getAnswer(int)
  - isCorrect
```
public abstract boolean isCorrect(R response,
                                  java.util.Map<java.lang.String,java.lang.String> args)
```
    Determines whether the submitted response to this question is correct.
    If your problem type defines correctness as when the student's response matches any one of the answers marked as a correct answer, then your subclass can implement this method to call #isCorrectDefault(StudentResponseValue).
    If your problem type requires a different semantic for determining correctness, you must implement that logic yourself in isCorrect(). In this case, your implementation may want (or need) to call setWrongAnswer(Answer) so that a common wrong answer is available later to a caller.
    
    Parameters:
    
    response - The student's response to compare to this problem's answer list.
    
    args - Map for problem specific properties that will be used in calculating correctness for the problem.
    
    Returns:
    
    true if the response matches one of the correct answers; otherwise false
    
    See Also:
    
    #isCorrectDefault(StudentResponseValue), setWrongAnswer(Answer)
  - isCorrect
```
public boolean isCorrect(R response)
```
    A convenience method for isCorrect that uses the problem's properties as arguments
  - isCorrectDefault
```
public boolean isCorrectDefault(R response,
                                java.util.Map<java.lang.String,java.lang.String> args)
```
    Provides a default implementation for use by isCorrect(StudentResponseValue).
    
    Parameters:
    
    response - The student's response
    
    args - problem specific properties
    
    Returns:
    
    true when response matches any one of the answers marked as a correct answer; otherwise false. "matches" is defined by your implementation of Answer#isMatch(StudentResponseValue).
    
    See Also:
    
    isCorrect(StudentResponseValue), Answer#isCorrect(StudentResponseValue), Answer#isMatch(StudentResponseValue), Answer#isMatchDefault(StudentResponseValue)
  - getAnswerValuePartsList
```
public java.util.List<P> getAnswerValuePartsList()
                                          throws java.lang.IllegalStateException
```
    Returns, in a single list, the answer value parts from all of the answers to this problem.
    getAnswerValuePartsList() expects that each answer contains exactly one value part.
    Use this method when you might need to sort an answer list's values.
    
    Throws:
    
    java.lang.IllegalStateException - if this problems answers have more than 1 value part per answer
    
    See Also:
    
    getProblemTypeAttributes()
  - setWrongAnswer
```
public void setWrongAnswer(A answer)
```
    Records the known wrong answer that matches a student's response.
    
    See Also:
    
    Answer#isMatch(StudentResponseValue), getWrongAnswer()
  - getWrongAnswer
```
public A getWrongAnswer()
```
    Returns the wrong Answer, if any, matched to the student's response.
    
    Returns:
    
    The known incorrect Answer or null if the student's response does not match any of the known incorrect answers.
    
    See Also:
    
    setWrongAnswer(Answer)
  - setCorrectAnswer
```
public void setCorrectAnswer(A answer)
```
    Records the known correct answer that matches a student's response.
    
    See Also:
    
    Answer#isMatch(StudentResponseValue), getCorrectAnswer()
  - getCorrectAnswer
```
public A getCorrectAnswer()
```
    Returns the correct Answer, if any, matched to the student's response.
    
    Returns:
    
    The known correct Answer or null if the student's response does not match any of the known correct answers.
    
    See Also:
    
    setCorrectAnswer(Answer)
  - validate
```
public void validate()
              throws ValidationException
```
    Description copied from interface: SelfValidating
    
    Check this object's data for inconsistencies Subclasses must (by informal contract) implement this method!
    
    Specified by:
    
    validate in interface SelfValidating
    
    Overrides:
    
    validate in class Problem
    
    Throws:
    
    ValidationException - if the data is invalid
  - isAnswerable
```
public static boolean isAnswerable(java.lang.String s)
```
  - addProperty
```
public void addProperty(java.lang.String key,
                        java.lang.String value)
```
  - getProperty
```
public java.lang.String getProperty(java.lang.String key)
```
  - getProperties
```
public java.util.Map<java.lang.String,java.lang.String> getProperties()
```
  - setProperties
```
public void setProperties(java.util.Map<java.lang.String,java.lang.String> properties)
```

Class AnswerableProblem<P extends AnswerValuePart,A extends Answer<P,V,R>,V extends TeacherAnswerValue<P,R>,R extends StudentResponseValue<P>>

Overview

Concrete Example

Defining Correctness

Building a New Problem Type

Field Summary

Fields inherited from class org.assistments.domain.content.tutor.Problem

Constructor Summary

Method Summary

Methods inherited from class org.assistments.domain.content.tutor.Problem

Methods inherited from class org.assistments.domain.content.tutor.AssessmentContent

Methods inherited from class org.assistments.domain.content.tutor.Content

Methods inherited from class org.assistments.domain.content.tutor.Persistable

Methods inherited from class java.lang.Object

Field Detail

answerableClasses

probProperties

Constructor Detail

AnswerableProblem

AnswerableProblem

Method Detail

addAnswer

makeResponse

registerProblemTypeAttributes

getProblemTypeAttributes

getUnscrambledAnswerIndexes

getUnscrambledAnswerIndexes

getProblemTypeAttributes

isScrambleAnswers

setScrambleAnswers

setAnswerEvalTypes

setAnswerEvalTypes

getAnswerEvalTypes

getAnswerEvalType

isAllowedAnswerEvalType

setResponseEvalTypes

setResponseEvalTypes

getResponseEvalTypes

getResponseEvalType

isAllowedResponseEvalType

getAnswerCount

getAnswers

getAnswers

getAnswer

setAnswers

addAnswer

isCorrect

isCorrect

isCorrectDefault

getAnswerValuePartsList

setWrongAnswer

getWrongAnswer

setCorrectAnswer

getCorrectAnswer

validate

isAnswerable

addProperty

getProperty

getProperties

setProperties