• Home
• com.amazonaws
• aws-java-sdk-dynamodb
• 1.11.642
• source code
• ExpectedAttributeValue.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.amazonaws.services.dynamodbv2.model.ExpectedAttributeValue Maven / Gradle / Ivy

/*
 * Copyright 2014-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
 * the License. A copy of the License is located at
 * 
 * http://aws.amazon.com/apache2.0
 * 
 * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
 * and limitations under the License.
 */
package com.amazonaws.services.dynamodbv2.model;

import java.io.Serializable;
import javax.annotation.Generated;
import com.amazonaws.protocol.StructuredPojo;
import com.amazonaws.protocol.ProtocolMarshaller;

/**
 * 

 * Represents a condition to be compared with an attribute value. This condition can be used with
 * DeleteItem, PutItem or UpdateItem operations; if the comparison evaluates to
 * true, the operation succeeds; if not, the operation fails. You can use ExpectedAttributeValue in one of
 * two different ways:
 * 
 * 

 * 

 * 

 * Use AttributeValueList to specify one or more values to compare against an attribute. Use
 * ComparisonOperator to specify how you want to perform the comparison. If the comparison evaluates to
 * true, then the conditional operation succeeds.
 * 
 * 
 * 

 * 

 * Use Value to specify a value that DynamoDB will compare against an attribute. If the values match, then
 * ExpectedAttributeValue evaluates to true and the conditional operation succeeds. Optionally, you can
 * also set Exists to false, indicating that you do not expect to find the attribute value in the
 * table. In this case, the conditional operation succeeds only if the comparison evaluates to false.
 * 
 * 
 * 
 * 

 * Value and Exists are incompatible with AttributeValueList and
 * ComparisonOperator. Note that if you use both sets of parameters at once, DynamoDB will return a
 * ValidationException exception.
 * 
 * 
 * @see AWS
 *      API Documentation
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class ExpectedAttributeValue implements Serializable, Cloneable, StructuredPojo {

    /**
     * 

     * Represents the data for the expected attribute.
     * 
     * 

     * Each attribute value is described as a name-value pair. The name is the data type, and the value is the data
     * itself.
     * 
     * 

     * For more information, see Data Types in the Amazon DynamoDB Developer Guide.
     * 
     */
    private AttributeValue value;
    /**
     * 

     * Causes DynamoDB to evaluate the value before attempting a conditional operation:
     * 
     * 

     * 

     * 

     * If Exists is true, DynamoDB will check to see if that attribute value already exists in
     * the table. If it is found, then the operation succeeds. If it is not found, the operation fails with a
     * ConditionCheckFailedException.
     * 
     * 
     * 

     * 

     * If Exists is false, DynamoDB assumes that the attribute value does not exist in the
     * table. If in fact the value does not exist, then the assumption is valid and the operation succeeds. If the value
     * is found, despite the assumption that it does not exist, the operation fails with a
     * ConditionCheckFailedException.
     * 
     * 
     * 
     * 

     * The default setting for Exists is true. If you supply a Value all by
     * itself, DynamoDB assumes the attribute exists: You don't have to set Exists to true,
     * because it is implied.
     * 
     * 

     * DynamoDB returns a ValidationException if:
     * 
     * 

     * 

     * 

     * Exists is true but there is no Value to check. (You expect a value to
     * exist, but don't specify what that value is.)
     * 
     * 
     * 

     * 

     * Exists is false but you also provide a Value. (You cannot expect an
     * attribute to have a value, while also expecting it not to exist.)
     * 
     * 
     * 
     */
    private Boolean exists;
    /**
     * 

     * A comparator for evaluating attributes in the AttributeValueList. For example, equals, greater than,
     * less than, etc.
     * 
     * 

     * The following comparison operators are available:
     * 
     * 

     * EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN
     * 
     * 

     * The following are descriptions of each comparison operator.
     * 
     * 

     * 

     * 

     * EQ : Equal. EQ is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     * {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NE : Not equal. NE is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, Binary,
     * String Set, Number Set, or Binary Set. If an item contains an AttributeValue of a different type
     * than the one provided in the request, the value does not match. For example, {"S":"6"} does not
     * equal {"N":"6"}. Also, {"N":"6"} does not equal {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LE : Less than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LT : Less than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, or
     * Binary (not a set type). If an item contains an AttributeValue element of a different type than the
     * one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GE : Greater than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GT : Greater than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NOT_NULL : The attribute exists. NOT_NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the existence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NOT_NULL, the result is a Boolean
     * true. This result is because the attribute "a" exists; its data type is not relevant to
     * the NOT_NULL comparison operator.
     * 
     * 
     * 

     * 

     * NULL : The attribute does not exist. NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the nonexistence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NULL, the result is a Boolean false.
     * This is because the attribute "a" exists; its data type is not relevant to the NULL
     * comparison operator.
     * 
     * 
     * 

     * 

     * CONTAINS : Checks for a subsequence, or value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is of type String, then the operator checks
     * for a substring match. If the target attribute of the comparison is of type Binary, then the operator looks for a
     * subsequence of the target that matches the input. If the target attribute of the comparison is a set ("
     * SS", "NS", or "BS"), then the operator evaluates to true if it finds an
     * exact match with any member of the set.
     * 
     * 

     * CONTAINS is supported for lists: When evaluating "a CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * NOT_CONTAINS : Checks for absence of a subsequence, or absence of a value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is a String, then the operator checks for
     * the absence of a substring match. If the target attribute of the comparison is Binary, then the operator checks
     * for the absence of a subsequence of the target that matches the input. If the target attribute of the comparison
     * is a set ("SS", "NS", or "BS"), then the operator evaluates to true if it
     * does not find an exact match with any member of the set.
     * 
     * 

     * NOT_CONTAINS is supported for lists: When evaluating "a NOT CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * BEGINS_WITH : Checks for a prefix.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String or Binary (not a
     * Number or a set type). The target attribute of the comparison must be of type String or Binary (not a Number or a
     * set type).
     * 
     * 

     * 

     * 

     * IN : Checks for matching elements in a list.
     * 
     * 

     * AttributeValueList can contain one or more AttributeValue elements of type String,
     * Number, or Binary. These attributes are compared against an existing attribute of an item. If any elements of the
     * input are equal to the item attribute, the expression evaluates to true.
     * 
     * 
     * 

     * 

     * BETWEEN : Greater than or equal to the first value, and less than or equal to the second value.
     * 
     * 

     * AttributeValueList must contain two AttributeValue elements of the same type, either
     * String, Number, or Binary (not a set type). A target attribute matches if the target value is greater than, or
     * equal to, the first element and less than, or equal to, the second element. If an item contains an
     * AttributeValue element of a different type than the one provided in the request, the value does not
     * match. For example, {"S":"6"} does not compare to {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2", "1"]}
     * 
     * 
     * 
     */
    private String comparisonOperator;
    /**
     * 

     * One or more values to evaluate against the supplied attribute. The number of values in the list depends on the
     * ComparisonOperator being used.
     * 
     * 

     * For type Number, value comparisons are numeric.
     * 
     * 

     * String value comparisons for greater than, equals, or less than are based on ASCII character code values. For
     * example, a is greater than A, and a is greater than B. For a
     * list of code values, see http://en.wikipedia
     * .org/wiki/ASCII#ASCII_printable_characters.
     * 
     * 

     * For Binary, DynamoDB treats each byte of the binary data as unsigned when it compares binary values.
     * 
     * 

     * For information on specifying data types in JSON, see JSON Data Format in
     * the Amazon DynamoDB Developer Guide.
     * 
     */
    private java.util.List attributeValueList;

    /**
     * Default constructor for ExpectedAttributeValue object. Callers should use the setter or fluent setter (with...)
     * methods to initialize the object after creating it.
     */
    public ExpectedAttributeValue() {
    }

    /**
     * Constructs a new ExpectedAttributeValue object. Callers should use the setter or fluent setter (with...) methods
     * to initialize any additional object members.
     * 
     * @param value
     *        Represents the data for the expected attribute.

     *        

     *        Each attribute value is described as a name-value pair. The name is the data type, and the value is the
     *        data itself.
     *        
     *        

     *        For more information, see Data Types in the Amazon DynamoDB Developer Guide.
     */
    public ExpectedAttributeValue(AttributeValue value) {
        setValue(value);
    }

    /**
     * Constructs a new ExpectedAttributeValue object. Callers should use the setter or fluent setter (with...) methods
     * to initialize any additional object members.
     * 
     * @param exists
     *        Causes DynamoDB to evaluate the value before attempting a conditional operation:
     *        

     *        

     *        

     *        If Exists is true, DynamoDB will check to see if that attribute value already
     *        exists in the table. If it is found, then the operation succeeds. If it is not found, the operation fails
     *        with a ConditionCheckFailedException.
     *        
     *        
     *        

     *        

     *        If Exists is false, DynamoDB assumes that the attribute value does not exist in
     *        the table. If in fact the value does not exist, then the assumption is valid and the operation succeeds.
     *        If the value is found, despite the assumption that it does not exist, the operation fails with a
     *        ConditionCheckFailedException.
     *        
     *        
     *        
     *        

     *        The default setting for Exists is true. If you supply a Value all
     *        by itself, DynamoDB assumes the attribute exists: You don't have to set Exists to
     *        true, because it is implied.
     *        
     *        

     *        DynamoDB returns a ValidationException if:
     *        
     *        

     *        

     *        

     *        Exists is true but there is no Value to check. (You expect a value
     *        to exist, but don't specify what that value is.)
     *        
     *        
     *        

     *        

     *        Exists is false but you also provide a Value. (You cannot expect an
     *        attribute to have a value, while also expecting it not to exist.)
     *        
     *        
     */
    public ExpectedAttributeValue(Boolean exists) {
        setExists(exists);
    }

    /**
     * 

     * Represents the data for the expected attribute.
     * 
     * 

     * Each attribute value is described as a name-value pair. The name is the data type, and the value is the data
     * itself.
     * 
     * 

     * For more information, see Data Types in the Amazon DynamoDB Developer Guide.
     * 
     * 
     * @param value
     *        Represents the data for the expected attribute.

     *        

     *        Each attribute value is described as a name-value pair. The name is the data type, and the value is the
     *        data itself.
     *        
     *        

     *        For more information, see Data Types in the Amazon DynamoDB Developer Guide.
     */

    public void setValue(AttributeValue value) {
        this.value = value;
    }

    /**
     * 

     * Represents the data for the expected attribute.
     * 
     * 

     * Each attribute value is described as a name-value pair. The name is the data type, and the value is the data
     * itself.
     * 
     * 

     * For more information, see Data Types in the Amazon DynamoDB Developer Guide.
     * 
     * 
     * @return Represents the data for the expected attribute.

     *         

     *         Each attribute value is described as a name-value pair. The name is the data type, and the value is the
     *         data itself.
     *         
     *         

     *         For more information, see Data Types in the Amazon DynamoDB Developer Guide.
     */

    public AttributeValue getValue() {
        return this.value;
    }

    /**
     * 

     * Represents the data for the expected attribute.
     * 
     * 

     * Each attribute value is described as a name-value pair. The name is the data type, and the value is the data
     * itself.
     * 
     * 

     * For more information, see Data Types in the Amazon DynamoDB Developer Guide.
     * 
     * 
     * @param value
     *        Represents the data for the expected attribute.

     *        

     *        Each attribute value is described as a name-value pair. The name is the data type, and the value is the
     *        data itself.
     *        
     *        

     *        For more information, see Data Types in the Amazon DynamoDB Developer Guide.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public ExpectedAttributeValue withValue(AttributeValue value) {
        setValue(value);
        return this;
    }

    /**
     * 

     * Causes DynamoDB to evaluate the value before attempting a conditional operation:
     * 
     * 

     * 

     * 

     * If Exists is true, DynamoDB will check to see if that attribute value already exists in
     * the table. If it is found, then the operation succeeds. If it is not found, the operation fails with a
     * ConditionCheckFailedException.
     * 
     * 
     * 

     * 

     * If Exists is false, DynamoDB assumes that the attribute value does not exist in the
     * table. If in fact the value does not exist, then the assumption is valid and the operation succeeds. If the value
     * is found, despite the assumption that it does not exist, the operation fails with a
     * ConditionCheckFailedException.
     * 
     * 
     * 
     * 

     * The default setting for Exists is true. If you supply a Value all by
     * itself, DynamoDB assumes the attribute exists: You don't have to set Exists to true,
     * because it is implied.
     * 
     * 

     * DynamoDB returns a ValidationException if:
     * 
     * 

     * 

     * 

     * Exists is true but there is no Value to check. (You expect a value to
     * exist, but don't specify what that value is.)
     * 
     * 
     * 

     * 

     * Exists is false but you also provide a Value. (You cannot expect an
     * attribute to have a value, while also expecting it not to exist.)
     * 
     * 
     * 
     * 
     * @param exists
     *        Causes DynamoDB to evaluate the value before attempting a conditional operation:

     *        

     *        

     *        

     *        If Exists is true, DynamoDB will check to see if that attribute value already
     *        exists in the table. If it is found, then the operation succeeds. If it is not found, the operation fails
     *        with a ConditionCheckFailedException.
     *        
     *        
     *        

     *        

     *        If Exists is false, DynamoDB assumes that the attribute value does not exist in
     *        the table. If in fact the value does not exist, then the assumption is valid and the operation succeeds.
     *        If the value is found, despite the assumption that it does not exist, the operation fails with a
     *        ConditionCheckFailedException.
     *        
     *        
     *        
     *        

     *        The default setting for Exists is true. If you supply a Value all
     *        by itself, DynamoDB assumes the attribute exists: You don't have to set Exists to
     *        true, because it is implied.
     *        
     *        

     *        DynamoDB returns a ValidationException if:
     *        
     *        

     *        

     *        

     *        Exists is true but there is no Value to check. (You expect a value
     *        to exist, but don't specify what that value is.)
     *        
     *        
     *        

     *        

     *        Exists is false but you also provide a Value. (You cannot expect an
     *        attribute to have a value, while also expecting it not to exist.)
     *        
     *        
     */

    public void setExists(Boolean exists) {
        this.exists = exists;
    }

    /**
     * 

     * Causes DynamoDB to evaluate the value before attempting a conditional operation:
     * 
     * 

     * 

     * 

     * If Exists is true, DynamoDB will check to see if that attribute value already exists in
     * the table. If it is found, then the operation succeeds. If it is not found, the operation fails with a
     * ConditionCheckFailedException.
     * 
     * 
     * 

     * 

     * If Exists is false, DynamoDB assumes that the attribute value does not exist in the
     * table. If in fact the value does not exist, then the assumption is valid and the operation succeeds. If the value
     * is found, despite the assumption that it does not exist, the operation fails with a
     * ConditionCheckFailedException.
     * 
     * 
     * 
     * 

     * The default setting for Exists is true. If you supply a Value all by
     * itself, DynamoDB assumes the attribute exists: You don't have to set Exists to true,
     * because it is implied.
     * 
     * 

     * DynamoDB returns a ValidationException if:
     * 
     * 

     * 

     * 

     * Exists is true but there is no Value to check. (You expect a value to
     * exist, but don't specify what that value is.)
     * 
     * 
     * 

     * 

     * Exists is false but you also provide a Value. (You cannot expect an
     * attribute to have a value, while also expecting it not to exist.)
     * 
     * 
     * 
     * 
     * @return Causes DynamoDB to evaluate the value before attempting a conditional operation:

     *         

     *         

     *         

     *         If Exists is true, DynamoDB will check to see if that attribute value already
     *         exists in the table. If it is found, then the operation succeeds. If it is not found, the operation fails
     *         with a ConditionCheckFailedException.
     *         
     *         
     *         

     *         

     *         If Exists is false, DynamoDB assumes that the attribute value does not exist in
     *         the table. If in fact the value does not exist, then the assumption is valid and the operation succeeds.
     *         If the value is found, despite the assumption that it does not exist, the operation fails with a
     *         ConditionCheckFailedException.
     *         
     *         
     *         
     *         

     *         The default setting for Exists is true. If you supply a Value all
     *         by itself, DynamoDB assumes the attribute exists: You don't have to set Exists to
     *         true, because it is implied.
     *         
     *         

     *         DynamoDB returns a ValidationException if:
     *         
     *         

     *         

     *         

     *         Exists is true but there is no Value to check. (You expect a value
     *         to exist, but don't specify what that value is.)
     *         
     *         
     *         

     *         

     *         Exists is false but you also provide a Value. (You cannot expect
     *         an attribute to have a value, while also expecting it not to exist.)
     *         
     *         
     */

    public Boolean getExists() {
        return this.exists;
    }

    /**
     * 

     * Causes DynamoDB to evaluate the value before attempting a conditional operation:
     * 
     * 

     * 

     * 

     * If Exists is true, DynamoDB will check to see if that attribute value already exists in
     * the table. If it is found, then the operation succeeds. If it is not found, the operation fails with a
     * ConditionCheckFailedException.
     * 
     * 
     * 

     * 

     * If Exists is false, DynamoDB assumes that the attribute value does not exist in the
     * table. If in fact the value does not exist, then the assumption is valid and the operation succeeds. If the value
     * is found, despite the assumption that it does not exist, the operation fails with a
     * ConditionCheckFailedException.
     * 
     * 
     * 
     * 

     * The default setting for Exists is true. If you supply a Value all by
     * itself, DynamoDB assumes the attribute exists: You don't have to set Exists to true,
     * because it is implied.
     * 
     * 

     * DynamoDB returns a ValidationException if:
     * 
     * 

     * 

     * 

     * Exists is true but there is no Value to check. (You expect a value to
     * exist, but don't specify what that value is.)
     * 
     * 
     * 

     * 

     * Exists is false but you also provide a Value. (You cannot expect an
     * attribute to have a value, while also expecting it not to exist.)
     * 
     * 
     * 
     * 
     * @param exists
     *        Causes DynamoDB to evaluate the value before attempting a conditional operation:

     *        

     *        

     *        

     *        If Exists is true, DynamoDB will check to see if that attribute value already
     *        exists in the table. If it is found, then the operation succeeds. If it is not found, the operation fails
     *        with a ConditionCheckFailedException.
     *        
     *        
     *        

     *        

     *        If Exists is false, DynamoDB assumes that the attribute value does not exist in
     *        the table. If in fact the value does not exist, then the assumption is valid and the operation succeeds.
     *        If the value is found, despite the assumption that it does not exist, the operation fails with a
     *        ConditionCheckFailedException.
     *        
     *        
     *        
     *        

     *        The default setting for Exists is true. If you supply a Value all
     *        by itself, DynamoDB assumes the attribute exists: You don't have to set Exists to
     *        true, because it is implied.
     *        
     *        

     *        DynamoDB returns a ValidationException if:
     *        
     *        

     *        

     *        

     *        Exists is true but there is no Value to check. (You expect a value
     *        to exist, but don't specify what that value is.)
     *        
     *        
     *        

     *        

     *        Exists is false but you also provide a Value. (You cannot expect an
     *        attribute to have a value, while also expecting it not to exist.)
     *        
     *        
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public ExpectedAttributeValue withExists(Boolean exists) {
        setExists(exists);
        return this;
    }

    /**
     * 

     * Causes DynamoDB to evaluate the value before attempting a conditional operation:
     * 
     * 

     * 

     * 

     * If Exists is true, DynamoDB will check to see if that attribute value already exists in
     * the table. If it is found, then the operation succeeds. If it is not found, the operation fails with a
     * ConditionCheckFailedException.
     * 
     * 
     * 

     * 

     * If Exists is false, DynamoDB assumes that the attribute value does not exist in the
     * table. If in fact the value does not exist, then the assumption is valid and the operation succeeds. If the value
     * is found, despite the assumption that it does not exist, the operation fails with a
     * ConditionCheckFailedException.
     * 
     * 
     * 
     * 

     * The default setting for Exists is true. If you supply a Value all by
     * itself, DynamoDB assumes the attribute exists: You don't have to set Exists to true,
     * because it is implied.
     * 
     * 

     * DynamoDB returns a ValidationException if:
     * 
     * 

     * 

     * 

     * Exists is true but there is no Value to check. (You expect a value to
     * exist, but don't specify what that value is.)
     * 
     * 
     * 

     * 

     * Exists is false but you also provide a Value. (You cannot expect an
     * attribute to have a value, while also expecting it not to exist.)
     * 
     * 
     * 
     * 
     * @return Causes DynamoDB to evaluate the value before attempting a conditional operation:

     *         

     *         

     *         

     *         If Exists is true, DynamoDB will check to see if that attribute value already
     *         exists in the table. If it is found, then the operation succeeds. If it is not found, the operation fails
     *         with a ConditionCheckFailedException.
     *         
     *         
     *         

     *         

     *         If Exists is false, DynamoDB assumes that the attribute value does not exist in
     *         the table. If in fact the value does not exist, then the assumption is valid and the operation succeeds.
     *         If the value is found, despite the assumption that it does not exist, the operation fails with a
     *         ConditionCheckFailedException.
     *         
     *         
     *         
     *         

     *         The default setting for Exists is true. If you supply a Value all
     *         by itself, DynamoDB assumes the attribute exists: You don't have to set Exists to
     *         true, because it is implied.
     *         
     *         

     *         DynamoDB returns a ValidationException if:
     *         
     *         

     *         

     *         

     *         Exists is true but there is no Value to check. (You expect a value
     *         to exist, but don't specify what that value is.)
     *         
     *         
     *         

     *         

     *         Exists is false but you also provide a Value. (You cannot expect
     *         an attribute to have a value, while also expecting it not to exist.)
     *         
     *         
     */

    public Boolean isExists() {
        return this.exists;
    }

    /**
     * 

     * A comparator for evaluating attributes in the AttributeValueList. For example, equals, greater than,
     * less than, etc.
     * 
     * 

     * The following comparison operators are available:
     * 
     * 

     * EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN
     * 
     * 

     * The following are descriptions of each comparison operator.
     * 
     * 

     * 

     * 

     * EQ : Equal. EQ is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     * {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NE : Not equal. NE is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, Binary,
     * String Set, Number Set, or Binary Set. If an item contains an AttributeValue of a different type
     * than the one provided in the request, the value does not match. For example, {"S":"6"} does not
     * equal {"N":"6"}. Also, {"N":"6"} does not equal {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LE : Less than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LT : Less than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, or
     * Binary (not a set type). If an item contains an AttributeValue element of a different type than the
     * one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GE : Greater than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GT : Greater than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NOT_NULL : The attribute exists. NOT_NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the existence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NOT_NULL, the result is a Boolean
     * true. This result is because the attribute "a" exists; its data type is not relevant to
     * the NOT_NULL comparison operator.
     * 
     * 
     * 

     * 

     * NULL : The attribute does not exist. NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the nonexistence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NULL, the result is a Boolean false.
     * This is because the attribute "a" exists; its data type is not relevant to the NULL
     * comparison operator.
     * 
     * 
     * 

     * 

     * CONTAINS : Checks for a subsequence, or value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is of type String, then the operator checks
     * for a substring match. If the target attribute of the comparison is of type Binary, then the operator looks for a
     * subsequence of the target that matches the input. If the target attribute of the comparison is a set ("
     * SS", "NS", or "BS"), then the operator evaluates to true if it finds an
     * exact match with any member of the set.
     * 
     * 

     * CONTAINS is supported for lists: When evaluating "a CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * NOT_CONTAINS : Checks for absence of a subsequence, or absence of a value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is a String, then the operator checks for
     * the absence of a substring match. If the target attribute of the comparison is Binary, then the operator checks
     * for the absence of a subsequence of the target that matches the input. If the target attribute of the comparison
     * is a set ("SS", "NS", or "BS"), then the operator evaluates to true if it
     * does not find an exact match with any member of the set.
     * 
     * 

     * NOT_CONTAINS is supported for lists: When evaluating "a NOT CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * BEGINS_WITH : Checks for a prefix.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String or Binary (not a
     * Number or a set type). The target attribute of the comparison must be of type String or Binary (not a Number or a
     * set type).
     * 
     * 

     * 

     * 

     * IN : Checks for matching elements in a list.
     * 
     * 

     * AttributeValueList can contain one or more AttributeValue elements of type String,
     * Number, or Binary. These attributes are compared against an existing attribute of an item. If any elements of the
     * input are equal to the item attribute, the expression evaluates to true.
     * 
     * 
     * 

     * 

     * BETWEEN : Greater than or equal to the first value, and less than or equal to the second value.
     * 
     * 

     * AttributeValueList must contain two AttributeValue elements of the same type, either
     * String, Number, or Binary (not a set type). A target attribute matches if the target value is greater than, or
     * equal to, the first element and less than, or equal to, the second element. If an item contains an
     * AttributeValue element of a different type than the one provided in the request, the value does not
     * match. For example, {"S":"6"} does not compare to {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2", "1"]}
     * 
     * 
     * 
     * 
     * @param comparisonOperator
     *        A comparator for evaluating attributes in the AttributeValueList. For example, equals,
     *        greater than, less than, etc.

     *        

     *        The following comparison operators are available:
     *        
     *        

     *        EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN
     *        
     *        

     *        The following are descriptions of each comparison operator.
     *        
     *        

     *        

     *        

     *        EQ : Equal. EQ is supported for all data types, including lists and maps.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue
     *        element of a different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        NE : Not equal. NE is supported for all data types, including lists and maps.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String, Number,
     *        Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        LE : Less than or equal.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        LT : Less than.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String, Number,
     *        or Binary (not a set type). If an item contains an AttributeValue element of a different type
     *        than the one provided in the request, the value does not match. For example, {"S":"6"} does
     *        not equal {"N":"6"}. Also, {"N":"6"} does not compare to
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        GE : Greater than or equal.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        GT : Greater than.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        NOT_NULL : The attribute exists. NOT_NULL is supported for all data types,
     *        including lists and maps.
     *        
     *        
     *        

     *        This operator tests for the existence of an attribute, not its data type. If the data type of attribute "
     *        a" is null, and you evaluate it using NOT_NULL, the result is a Boolean
     *        true. This result is because the attribute "a" exists; its data type is not
     *        relevant to the NOT_NULL comparison operator.
     *        
     *        
     *        

     *        

     *        NULL : The attribute does not exist. NULL is supported for all data types,
     *        including lists and maps.
     *        
     *        
     *        

     *        This operator tests for the nonexistence of an attribute, not its data type. If the data type of attribute
     *        "a" is null, and you evaluate it using NULL, the result is a Boolean
     *        false. This is because the attribute "a" exists; its data type is not relevant
     *        to the NULL comparison operator.
     *        
     *        
     *        

     *        

     *        CONTAINS : Checks for a subsequence, or value in a set.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If the target attribute of the comparison is of type String, then the
     *        operator checks for a substring match. If the target attribute of the comparison is of type Binary, then
     *        the operator looks for a subsequence of the target that matches the input. If the target attribute of the
     *        comparison is a set ("SS", "NS", or "BS"), then the operator
     *        evaluates to true if it finds an exact match with any member of the set.
     *        
     *        

     *        CONTAINS is supported for lists: When evaluating "a CONTAINS b", "a
     *        " can be a list; however, "b" cannot be a set, a map, or a list.
     *        
     *        
     *        

     *        

     *        NOT_CONTAINS : Checks for absence of a subsequence, or absence of a value in a set.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If the target attribute of the comparison is a String, then the
     *        operator checks for the absence of a substring match. If the target attribute of the comparison is Binary,
     *        then the operator checks for the absence of a subsequence of the target that matches the input. If the
     *        target attribute of the comparison is a set ("SS", "NS", or "BS"),
     *        then the operator evaluates to true if it does not find an exact match with any member of the set.
     *        
     *        

     *        NOT_CONTAINS is supported for lists: When evaluating "a NOT CONTAINS b", "a
     *        " can be a list; however, "b" cannot be a set, a map, or a list.
     *        
     *        
     *        

     *        

     *        BEGINS_WITH : Checks for a prefix.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String or Binary
     *        (not a Number or a set type). The target attribute of the comparison must be of type String or Binary (not
     *        a Number or a set type).
     *        
     *        

     *        

     *        

     *        IN : Checks for matching elements in a list.
     *        
     *        

     *        AttributeValueList can contain one or more AttributeValue elements of type
     *        String, Number, or Binary. These attributes are compared against an existing attribute of an item. If any
     *        elements of the input are equal to the item attribute, the expression evaluates to true.
     *        
     *        
     *        

     *        

     *        BETWEEN : Greater than or equal to the first value, and less than or equal to the second
     *        value.
     *        
     *        

     *        AttributeValueList must contain two AttributeValue elements of the same type,
     *        either String, Number, or Binary (not a set type). A target attribute matches if the target value is
     *        greater than, or equal to, the first element and less than, or equal to, the second element. If an item
     *        contains an AttributeValue element of a different type than the one provided in the request,
     *        the value does not match. For example, {"S":"6"} does not compare to {"N":"6"}.
     *        Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}
     *        
     *        
     * @see ComparisonOperator
     */

    public void setComparisonOperator(String comparisonOperator) {
        this.comparisonOperator = comparisonOperator;
    }

    /**
     * 

     * A comparator for evaluating attributes in the AttributeValueList. For example, equals, greater than,
     * less than, etc.
     * 
     * 

     * The following comparison operators are available:
     * 
     * 

     * EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN
     * 
     * 

     * The following are descriptions of each comparison operator.
     * 
     * 

     * 

     * 

     * EQ : Equal. EQ is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     * {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NE : Not equal. NE is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, Binary,
     * String Set, Number Set, or Binary Set. If an item contains an AttributeValue of a different type
     * than the one provided in the request, the value does not match. For example, {"S":"6"} does not
     * equal {"N":"6"}. Also, {"N":"6"} does not equal {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LE : Less than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LT : Less than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, or
     * Binary (not a set type). If an item contains an AttributeValue element of a different type than the
     * one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GE : Greater than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GT : Greater than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NOT_NULL : The attribute exists. NOT_NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the existence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NOT_NULL, the result is a Boolean
     * true. This result is because the attribute "a" exists; its data type is not relevant to
     * the NOT_NULL comparison operator.
     * 
     * 
     * 

     * 

     * NULL : The attribute does not exist. NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the nonexistence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NULL, the result is a Boolean false.
     * This is because the attribute "a" exists; its data type is not relevant to the NULL
     * comparison operator.
     * 
     * 
     * 

     * 

     * CONTAINS : Checks for a subsequence, or value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is of type String, then the operator checks
     * for a substring match. If the target attribute of the comparison is of type Binary, then the operator looks for a
     * subsequence of the target that matches the input. If the target attribute of the comparison is a set ("
     * SS", "NS", or "BS"), then the operator evaluates to true if it finds an
     * exact match with any member of the set.
     * 
     * 

     * CONTAINS is supported for lists: When evaluating "a CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * NOT_CONTAINS : Checks for absence of a subsequence, or absence of a value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is a String, then the operator checks for
     * the absence of a substring match. If the target attribute of the comparison is Binary, then the operator checks
     * for the absence of a subsequence of the target that matches the input. If the target attribute of the comparison
     * is a set ("SS", "NS", or "BS"), then the operator evaluates to true if it
     * does not find an exact match with any member of the set.
     * 
     * 

     * NOT_CONTAINS is supported for lists: When evaluating "a NOT CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * BEGINS_WITH : Checks for a prefix.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String or Binary (not a
     * Number or a set type). The target attribute of the comparison must be of type String or Binary (not a Number or a
     * set type).
     * 
     * 

     * 

     * 

     * IN : Checks for matching elements in a list.
     * 
     * 

     * AttributeValueList can contain one or more AttributeValue elements of type String,
     * Number, or Binary. These attributes are compared against an existing attribute of an item. If any elements of the
     * input are equal to the item attribute, the expression evaluates to true.
     * 
     * 
     * 

     * 

     * BETWEEN : Greater than or equal to the first value, and less than or equal to the second value.
     * 
     * 

     * AttributeValueList must contain two AttributeValue elements of the same type, either
     * String, Number, or Binary (not a set type). A target attribute matches if the target value is greater than, or
     * equal to, the first element and less than, or equal to, the second element. If an item contains an
     * AttributeValue element of a different type than the one provided in the request, the value does not
     * match. For example, {"S":"6"} does not compare to {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2", "1"]}
     * 
     * 
     * 
     * 
     * @return A comparator for evaluating attributes in the AttributeValueList. For example, equals,
     *         greater than, less than, etc.

     *         

     *         The following comparison operators are available:
     *         
     *         

     *         EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN
     *         
     *         

     *         The following are descriptions of each comparison operator.
     *         
     *         

     *         

     *         

     *         EQ : Equal. EQ is supported for all data types, including lists and maps.
     *         
     *         

     *         AttributeValueList can contain only one AttributeValue element of type String,
     *         Number, Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue
     *         element of a different type than the one provided in the request, the value does not match. For example,
     *         {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     *         {"NS":["6", "2", "1"]}.
     *         
     *         

     *         

     *         

     *         NE : Not equal. NE is supported for all data types, including lists and maps.
     *         
     *         

     *         AttributeValueList can contain only one AttributeValue of type String, Number,
     *         Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue of a
     *         different type than the one provided in the request, the value does not match. For example,
     *         {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     *         {"NS":["6", "2", "1"]}.
     *         
     *         

     *         

     *         

     *         LE : Less than or equal.
     *         
     *         

     *         AttributeValueList can contain only one AttributeValue element of type String,
     *         Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does not match. For example,
     *         {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *         compare to {"NS":["6", "2", "1"]}.
     *         
     *         

     *         

     *         

     *         LT : Less than.
     *         
     *         

     *         AttributeValueList can contain only one AttributeValue of type String, Number,
     *         or Binary (not a set type). If an item contains an AttributeValue element of a different
     *         type than the one provided in the request, the value does not match. For example, {"S":"6"}
     *         does not equal {"N":"6"}. Also, {"N":"6"} does not compare to
     *         {"NS":["6", "2", "1"]}.
     *         
     *         

     *         

     *         

     *         GE : Greater than or equal.
     *         
     *         

     *         AttributeValueList can contain only one AttributeValue element of type String,
     *         Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does not match. For example,
     *         {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *         compare to {"NS":["6", "2", "1"]}.
     *         
     *         

     *         

     *         

     *         GT : Greater than.
     *         
     *         

     *         AttributeValueList can contain only one AttributeValue element of type String,
     *         Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does not match. For example,
     *         {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *         compare to {"NS":["6", "2", "1"]}.
     *         
     *         

     *         

     *         

     *         NOT_NULL : The attribute exists. NOT_NULL is supported for all data types,
     *         including lists and maps.
     *         
     *         
     *         

     *         This operator tests for the existence of an attribute, not its data type. If the data type of attribute "
     *         a" is null, and you evaluate it using NOT_NULL, the result is a Boolean
     *         true. This result is because the attribute "a" exists; its data type is not
     *         relevant to the NOT_NULL comparison operator.
     *         
     *         
     *         

     *         

     *         NULL : The attribute does not exist. NULL is supported for all data types,
     *         including lists and maps.
     *         
     *         
     *         

     *         This operator tests for the nonexistence of an attribute, not its data type. If the data type of
     *         attribute "a" is null, and you evaluate it using NULL, the result is a Boolean
     *         false. This is because the attribute "a" exists; its data type is not relevant
     *         to the NULL comparison operator.
     *         
     *         
     *         

     *         

     *         CONTAINS : Checks for a subsequence, or value in a set.
     *         
     *         

     *         AttributeValueList can contain only one AttributeValue element of type String,
     *         Number, or Binary (not a set type). If the target attribute of the comparison is of type String, then the
     *         operator checks for a substring match. If the target attribute of the comparison is of type Binary, then
     *         the operator looks for a subsequence of the target that matches the input. If the target attribute of the
     *         comparison is a set ("SS", "NS", or "BS"), then the operator
     *         evaluates to true if it finds an exact match with any member of the set.
     *         
     *         

     *         CONTAINS is supported for lists: When evaluating "a CONTAINS b", "a
     *         " can be a list; however, "b" cannot be a set, a map, or a list.
     *         
     *         
     *         

     *         

     *         NOT_CONTAINS : Checks for absence of a subsequence, or absence of a value in a set.
     *         
     *         

     *         AttributeValueList can contain only one AttributeValue element of type String,
     *         Number, or Binary (not a set type). If the target attribute of the comparison is a String, then the
     *         operator checks for the absence of a substring match. If the target attribute of the comparison is
     *         Binary, then the operator checks for the absence of a subsequence of the target that matches the input.
     *         If the target attribute of the comparison is a set ("SS", "NS", or "
     *         BS"), then the operator evaluates to true if it does not find an exact match with any
     *         member of the set.
     *         
     *         

     *         NOT_CONTAINS is supported for lists: When evaluating "a NOT CONTAINS b", "a
     *         " can be a list; however, "b" cannot be a set, a map, or a list.
     *         
     *         
     *         

     *         

     *         BEGINS_WITH : Checks for a prefix.
     *         
     *         

     *         AttributeValueList can contain only one AttributeValue of type String or Binary
     *         (not a Number or a set type). The target attribute of the comparison must be of type String or Binary
     *         (not a Number or a set type).
     *         
     *         

     *         

     *         

     *         IN : Checks for matching elements in a list.
     *         
     *         

     *         AttributeValueList can contain one or more AttributeValue elements of type
     *         String, Number, or Binary. These attributes are compared against an existing attribute of an item. If any
     *         elements of the input are equal to the item attribute, the expression evaluates to true.
     *         
     *         
     *         

     *         

     *         BETWEEN : Greater than or equal to the first value, and less than or equal to the second
     *         value.
     *         
     *         

     *         AttributeValueList must contain two AttributeValue elements of the same type,
     *         either String, Number, or Binary (not a set type). A target attribute matches if the target value is
     *         greater than, or equal to, the first element and less than, or equal to, the second element. If an item
     *         contains an AttributeValue element of a different type than the one provided in the request,
     *         the value does not match. For example, {"S":"6"} does not compare to {"N":"6"}.
     *         Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}
     *         
     *         
     * @see ComparisonOperator
     */

    public String getComparisonOperator() {
        return this.comparisonOperator;
    }

    /**
     * 

     * A comparator for evaluating attributes in the AttributeValueList. For example, equals, greater than,
     * less than, etc.
     * 
     * 

     * The following comparison operators are available:
     * 
     * 

     * EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN
     * 
     * 

     * The following are descriptions of each comparison operator.
     * 
     * 

     * 

     * 

     * EQ : Equal. EQ is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     * {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NE : Not equal. NE is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, Binary,
     * String Set, Number Set, or Binary Set. If an item contains an AttributeValue of a different type
     * than the one provided in the request, the value does not match. For example, {"S":"6"} does not
     * equal {"N":"6"}. Also, {"N":"6"} does not equal {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LE : Less than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LT : Less than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, or
     * Binary (not a set type). If an item contains an AttributeValue element of a different type than the
     * one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GE : Greater than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GT : Greater than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NOT_NULL : The attribute exists. NOT_NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the existence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NOT_NULL, the result is a Boolean
     * true. This result is because the attribute "a" exists; its data type is not relevant to
     * the NOT_NULL comparison operator.
     * 
     * 
     * 

     * 

     * NULL : The attribute does not exist. NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the nonexistence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NULL, the result is a Boolean false.
     * This is because the attribute "a" exists; its data type is not relevant to the NULL
     * comparison operator.
     * 
     * 
     * 

     * 

     * CONTAINS : Checks for a subsequence, or value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is of type String, then the operator checks
     * for a substring match. If the target attribute of the comparison is of type Binary, then the operator looks for a
     * subsequence of the target that matches the input. If the target attribute of the comparison is a set ("
     * SS", "NS", or "BS"), then the operator evaluates to true if it finds an
     * exact match with any member of the set.
     * 
     * 

     * CONTAINS is supported for lists: When evaluating "a CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * NOT_CONTAINS : Checks for absence of a subsequence, or absence of a value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is a String, then the operator checks for
     * the absence of a substring match. If the target attribute of the comparison is Binary, then the operator checks
     * for the absence of a subsequence of the target that matches the input. If the target attribute of the comparison
     * is a set ("SS", "NS", or "BS"), then the operator evaluates to true if it
     * does not find an exact match with any member of the set.
     * 
     * 

     * NOT_CONTAINS is supported for lists: When evaluating "a NOT CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * BEGINS_WITH : Checks for a prefix.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String or Binary (not a
     * Number or a set type). The target attribute of the comparison must be of type String or Binary (not a Number or a
     * set type).
     * 
     * 

     * 

     * 

     * IN : Checks for matching elements in a list.
     * 
     * 

     * AttributeValueList can contain one or more AttributeValue elements of type String,
     * Number, or Binary. These attributes are compared against an existing attribute of an item. If any elements of the
     * input are equal to the item attribute, the expression evaluates to true.
     * 
     * 
     * 

     * 

     * BETWEEN : Greater than or equal to the first value, and less than or equal to the second value.
     * 
     * 

     * AttributeValueList must contain two AttributeValue elements of the same type, either
     * String, Number, or Binary (not a set type). A target attribute matches if the target value is greater than, or
     * equal to, the first element and less than, or equal to, the second element. If an item contains an
     * AttributeValue element of a different type than the one provided in the request, the value does not
     * match. For example, {"S":"6"} does not compare to {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2", "1"]}
     * 
     * 
     * 
     * 
     * @param comparisonOperator
     *        A comparator for evaluating attributes in the AttributeValueList. For example, equals,
     *        greater than, less than, etc.

     *        

     *        The following comparison operators are available:
     *        
     *        

     *        EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN
     *        
     *        

     *        The following are descriptions of each comparison operator.
     *        
     *        

     *        

     *        

     *        EQ : Equal. EQ is supported for all data types, including lists and maps.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue
     *        element of a different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        NE : Not equal. NE is supported for all data types, including lists and maps.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String, Number,
     *        Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        LE : Less than or equal.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        LT : Less than.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String, Number,
     *        or Binary (not a set type). If an item contains an AttributeValue element of a different type
     *        than the one provided in the request, the value does not match. For example, {"S":"6"} does
     *        not equal {"N":"6"}. Also, {"N":"6"} does not compare to
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        GE : Greater than or equal.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        GT : Greater than.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        NOT_NULL : The attribute exists. NOT_NULL is supported for all data types,
     *        including lists and maps.
     *        
     *        
     *        

     *        This operator tests for the existence of an attribute, not its data type. If the data type of attribute "
     *        a" is null, and you evaluate it using NOT_NULL, the result is a Boolean
     *        true. This result is because the attribute "a" exists; its data type is not
     *        relevant to the NOT_NULL comparison operator.
     *        
     *        
     *        

     *        

     *        NULL : The attribute does not exist. NULL is supported for all data types,
     *        including lists and maps.
     *        
     *        
     *        

     *        This operator tests for the nonexistence of an attribute, not its data type. If the data type of attribute
     *        "a" is null, and you evaluate it using NULL, the result is a Boolean
     *        false. This is because the attribute "a" exists; its data type is not relevant
     *        to the NULL comparison operator.
     *        
     *        
     *        

     *        

     *        CONTAINS : Checks for a subsequence, or value in a set.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If the target attribute of the comparison is of type String, then the
     *        operator checks for a substring match. If the target attribute of the comparison is of type Binary, then
     *        the operator looks for a subsequence of the target that matches the input. If the target attribute of the
     *        comparison is a set ("SS", "NS", or "BS"), then the operator
     *        evaluates to true if it finds an exact match with any member of the set.
     *        
     *        

     *        CONTAINS is supported for lists: When evaluating "a CONTAINS b", "a
     *        " can be a list; however, "b" cannot be a set, a map, or a list.
     *        
     *        
     *        

     *        

     *        NOT_CONTAINS : Checks for absence of a subsequence, or absence of a value in a set.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If the target attribute of the comparison is a String, then the
     *        operator checks for the absence of a substring match. If the target attribute of the comparison is Binary,
     *        then the operator checks for the absence of a subsequence of the target that matches the input. If the
     *        target attribute of the comparison is a set ("SS", "NS", or "BS"),
     *        then the operator evaluates to true if it does not find an exact match with any member of the set.
     *        
     *        

     *        NOT_CONTAINS is supported for lists: When evaluating "a NOT CONTAINS b", "a
     *        " can be a list; however, "b" cannot be a set, a map, or a list.
     *        
     *        
     *        

     *        

     *        BEGINS_WITH : Checks for a prefix.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String or Binary
     *        (not a Number or a set type). The target attribute of the comparison must be of type String or Binary (not
     *        a Number or a set type).
     *        
     *        

     *        

     *        

     *        IN : Checks for matching elements in a list.
     *        
     *        

     *        AttributeValueList can contain one or more AttributeValue elements of type
     *        String, Number, or Binary. These attributes are compared against an existing attribute of an item. If any
     *        elements of the input are equal to the item attribute, the expression evaluates to true.
     *        
     *        
     *        

     *        

     *        BETWEEN : Greater than or equal to the first value, and less than or equal to the second
     *        value.
     *        
     *        

     *        AttributeValueList must contain two AttributeValue elements of the same type,
     *        either String, Number, or Binary (not a set type). A target attribute matches if the target value is
     *        greater than, or equal to, the first element and less than, or equal to, the second element. If an item
     *        contains an AttributeValue element of a different type than the one provided in the request,
     *        the value does not match. For example, {"S":"6"} does not compare to {"N":"6"}.
     *        Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}
     *        
     *        
     * @return Returns a reference to this object so that method calls can be chained together.
     * @see ComparisonOperator
     */

    public ExpectedAttributeValue withComparisonOperator(String comparisonOperator) {
        setComparisonOperator(comparisonOperator);
        return this;
    }

    /**
     * 

     * A comparator for evaluating attributes in the AttributeValueList. For example, equals, greater than,
     * less than, etc.
     * 
     * 

     * The following comparison operators are available:
     * 
     * 

     * EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN
     * 
     * 

     * The following are descriptions of each comparison operator.
     * 
     * 

     * 

     * 

     * EQ : Equal. EQ is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     * {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NE : Not equal. NE is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, Binary,
     * String Set, Number Set, or Binary Set. If an item contains an AttributeValue of a different type
     * than the one provided in the request, the value does not match. For example, {"S":"6"} does not
     * equal {"N":"6"}. Also, {"N":"6"} does not equal {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LE : Less than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LT : Less than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, or
     * Binary (not a set type). If an item contains an AttributeValue element of a different type than the
     * one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GE : Greater than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GT : Greater than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NOT_NULL : The attribute exists. NOT_NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the existence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NOT_NULL, the result is a Boolean
     * true. This result is because the attribute "a" exists; its data type is not relevant to
     * the NOT_NULL comparison operator.
     * 
     * 
     * 

     * 

     * NULL : The attribute does not exist. NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the nonexistence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NULL, the result is a Boolean false.
     * This is because the attribute "a" exists; its data type is not relevant to the NULL
     * comparison operator.
     * 
     * 
     * 

     * 

     * CONTAINS : Checks for a subsequence, or value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is of type String, then the operator checks
     * for a substring match. If the target attribute of the comparison is of type Binary, then the operator looks for a
     * subsequence of the target that matches the input. If the target attribute of the comparison is a set ("
     * SS", "NS", or "BS"), then the operator evaluates to true if it finds an
     * exact match with any member of the set.
     * 
     * 

     * CONTAINS is supported for lists: When evaluating "a CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * NOT_CONTAINS : Checks for absence of a subsequence, or absence of a value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is a String, then the operator checks for
     * the absence of a substring match. If the target attribute of the comparison is Binary, then the operator checks
     * for the absence of a subsequence of the target that matches the input. If the target attribute of the comparison
     * is a set ("SS", "NS", or "BS"), then the operator evaluates to true if it
     * does not find an exact match with any member of the set.
     * 
     * 

     * NOT_CONTAINS is supported for lists: When evaluating "a NOT CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * BEGINS_WITH : Checks for a prefix.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String or Binary (not a
     * Number or a set type). The target attribute of the comparison must be of type String or Binary (not a Number or a
     * set type).
     * 
     * 

     * 

     * 

     * IN : Checks for matching elements in a list.
     * 
     * 

     * AttributeValueList can contain one or more AttributeValue elements of type String,
     * Number, or Binary. These attributes are compared against an existing attribute of an item. If any elements of the
     * input are equal to the item attribute, the expression evaluates to true.
     * 
     * 
     * 

     * 

     * BETWEEN : Greater than or equal to the first value, and less than or equal to the second value.
     * 
     * 

     * AttributeValueList must contain two AttributeValue elements of the same type, either
     * String, Number, or Binary (not a set type). A target attribute matches if the target value is greater than, or
     * equal to, the first element and less than, or equal to, the second element. If an item contains an
     * AttributeValue element of a different type than the one provided in the request, the value does not
     * match. For example, {"S":"6"} does not compare to {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2", "1"]}
     * 
     * 
     * 
     * 
     * @param comparisonOperator
     *        A comparator for evaluating attributes in the AttributeValueList. For example, equals,
     *        greater than, less than, etc.

     *        

     *        The following comparison operators are available:
     *        
     *        

     *        EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN
     *        
     *        

     *        The following are descriptions of each comparison operator.
     *        
     *        

     *        

     *        

     *        EQ : Equal. EQ is supported for all data types, including lists and maps.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue
     *        element of a different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        NE : Not equal. NE is supported for all data types, including lists and maps.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String, Number,
     *        Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        LE : Less than or equal.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        LT : Less than.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String, Number,
     *        or Binary (not a set type). If an item contains an AttributeValue element of a different type
     *        than the one provided in the request, the value does not match. For example, {"S":"6"} does
     *        not equal {"N":"6"}. Also, {"N":"6"} does not compare to
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        GE : Greater than or equal.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        GT : Greater than.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        NOT_NULL : The attribute exists. NOT_NULL is supported for all data types,
     *        including lists and maps.
     *        
     *        
     *        

     *        This operator tests for the existence of an attribute, not its data type. If the data type of attribute "
     *        a" is null, and you evaluate it using NOT_NULL, the result is a Boolean
     *        true. This result is because the attribute "a" exists; its data type is not
     *        relevant to the NOT_NULL comparison operator.
     *        
     *        
     *        

     *        

     *        NULL : The attribute does not exist. NULL is supported for all data types,
     *        including lists and maps.
     *        
     *        
     *        

     *        This operator tests for the nonexistence of an attribute, not its data type. If the data type of attribute
     *        "a" is null, and you evaluate it using NULL, the result is a Boolean
     *        false. This is because the attribute "a" exists; its data type is not relevant
     *        to the NULL comparison operator.
     *        
     *        
     *        

     *        

     *        CONTAINS : Checks for a subsequence, or value in a set.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If the target attribute of the comparison is of type String, then the
     *        operator checks for a substring match. If the target attribute of the comparison is of type Binary, then
     *        the operator looks for a subsequence of the target that matches the input. If the target attribute of the
     *        comparison is a set ("SS", "NS", or "BS"), then the operator
     *        evaluates to true if it finds an exact match with any member of the set.
     *        
     *        

     *        CONTAINS is supported for lists: When evaluating "a CONTAINS b", "a
     *        " can be a list; however, "b" cannot be a set, a map, or a list.
     *        
     *        
     *        

     *        

     *        NOT_CONTAINS : Checks for absence of a subsequence, or absence of a value in a set.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If the target attribute of the comparison is a String, then the
     *        operator checks for the absence of a substring match. If the target attribute of the comparison is Binary,
     *        then the operator checks for the absence of a subsequence of the target that matches the input. If the
     *        target attribute of the comparison is a set ("SS", "NS", or "BS"),
     *        then the operator evaluates to true if it does not find an exact match with any member of the set.
     *        
     *        

     *        NOT_CONTAINS is supported for lists: When evaluating "a NOT CONTAINS b", "a
     *        " can be a list; however, "b" cannot be a set, a map, or a list.
     *        
     *        
     *        

     *        

     *        BEGINS_WITH : Checks for a prefix.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String or Binary
     *        (not a Number or a set type). The target attribute of the comparison must be of type String or Binary (not
     *        a Number or a set type).
     *        
     *        

     *        

     *        

     *        IN : Checks for matching elements in a list.
     *        
     *        

     *        AttributeValueList can contain one or more AttributeValue elements of type
     *        String, Number, or Binary. These attributes are compared against an existing attribute of an item. If any
     *        elements of the input are equal to the item attribute, the expression evaluates to true.
     *        
     *        
     *        

     *        

     *        BETWEEN : Greater than or equal to the first value, and less than or equal to the second
     *        value.
     *        
     *        

     *        AttributeValueList must contain two AttributeValue elements of the same type,
     *        either String, Number, or Binary (not a set type). A target attribute matches if the target value is
     *        greater than, or equal to, the first element and less than, or equal to, the second element. If an item
     *        contains an AttributeValue element of a different type than the one provided in the request,
     *        the value does not match. For example, {"S":"6"} does not compare to {"N":"6"}.
     *        Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}
     *        
     *        
     * @see ComparisonOperator
     */

    public void setComparisonOperator(ComparisonOperator comparisonOperator) {
        withComparisonOperator(comparisonOperator);
    }

    /**
     * 

     * A comparator for evaluating attributes in the AttributeValueList. For example, equals, greater than,
     * less than, etc.
     * 
     * 

     * The following comparison operators are available:
     * 
     * 

     * EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN
     * 
     * 

     * The following are descriptions of each comparison operator.
     * 
     * 

     * 

     * 

     * EQ : Equal. EQ is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     * {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NE : Not equal. NE is supported for all data types, including lists and maps.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, Binary,
     * String Set, Number Set, or Binary Set. If an item contains an AttributeValue of a different type
     * than the one provided in the request, the value does not match. For example, {"S":"6"} does not
     * equal {"N":"6"}. Also, {"N":"6"} does not equal {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LE : Less than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * LT : Less than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String, Number, or
     * Binary (not a set type). If an item contains an AttributeValue element of a different type than the
     * one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GE : Greater than or equal.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * GT : Greater than.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an AttributeValue element of a different type than
     * the one provided in the request, the value does not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}.
     * 
     * 

     * 

     * 

     * NOT_NULL : The attribute exists. NOT_NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the existence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NOT_NULL, the result is a Boolean
     * true. This result is because the attribute "a" exists; its data type is not relevant to
     * the NOT_NULL comparison operator.
     * 
     * 
     * 

     * 

     * NULL : The attribute does not exist. NULL is supported for all data types, including
     * lists and maps.
     * 
     * 
     * 

     * This operator tests for the nonexistence of an attribute, not its data type. If the data type of attribute "
     * a" is null, and you evaluate it using NULL, the result is a Boolean false.
     * This is because the attribute "a" exists; its data type is not relevant to the NULL
     * comparison operator.
     * 
     * 
     * 

     * 

     * CONTAINS : Checks for a subsequence, or value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is of type String, then the operator checks
     * for a substring match. If the target attribute of the comparison is of type Binary, then the operator looks for a
     * subsequence of the target that matches the input. If the target attribute of the comparison is a set ("
     * SS", "NS", or "BS"), then the operator evaluates to true if it finds an
     * exact match with any member of the set.
     * 
     * 

     * CONTAINS is supported for lists: When evaluating "a CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * NOT_CONTAINS : Checks for absence of a subsequence, or absence of a value in a set.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If the target attribute of the comparison is a String, then the operator checks for
     * the absence of a substring match. If the target attribute of the comparison is Binary, then the operator checks
     * for the absence of a subsequence of the target that matches the input. If the target attribute of the comparison
     * is a set ("SS", "NS", or "BS"), then the operator evaluates to true if it
     * does not find an exact match with any member of the set.
     * 
     * 

     * NOT_CONTAINS is supported for lists: When evaluating "a NOT CONTAINS b", "a
     * " can be a list; however, "b" cannot be a set, a map, or a list.
     * 
     * 
     * 

     * 

     * BEGINS_WITH : Checks for a prefix.
     * 
     * 

     * AttributeValueList can contain only one AttributeValue of type String or Binary (not a
     * Number or a set type). The target attribute of the comparison must be of type String or Binary (not a Number or a
     * set type).
     * 
     * 

     * 

     * 

     * IN : Checks for matching elements in a list.
     * 
     * 

     * AttributeValueList can contain one or more AttributeValue elements of type String,
     * Number, or Binary. These attributes are compared against an existing attribute of an item. If any elements of the
     * input are equal to the item attribute, the expression evaluates to true.
     * 
     * 
     * 

     * 

     * BETWEEN : Greater than or equal to the first value, and less than or equal to the second value.
     * 
     * 

     * AttributeValueList must contain two AttributeValue elements of the same type, either
     * String, Number, or Binary (not a set type). A target attribute matches if the target value is greater than, or
     * equal to, the first element and less than, or equal to, the second element. If an item contains an
     * AttributeValue element of a different type than the one provided in the request, the value does not
     * match. For example, {"S":"6"} does not compare to {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2", "1"]}
     * 
     * 
     * 
     * 
     * @param comparisonOperator
     *        A comparator for evaluating attributes in the AttributeValueList. For example, equals,
     *        greater than, less than, etc.

     *        

     *        The following comparison operators are available:
     *        
     *        

     *        EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN
     *        
     *        

     *        The following are descriptions of each comparison operator.
     *        
     *        

     *        

     *        

     *        EQ : Equal. EQ is supported for all data types, including lists and maps.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue
     *        element of a different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        NE : Not equal. NE is supported for all data types, including lists and maps.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String, Number,
     *        Binary, String Set, Number Set, or Binary Set. If an item contains an AttributeValue of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        LE : Less than or equal.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        LT : Less than.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String, Number,
     *        or Binary (not a set type). If an item contains an AttributeValue element of a different type
     *        than the one provided in the request, the value does not match. For example, {"S":"6"} does
     *        not equal {"N":"6"}. Also, {"N":"6"} does not compare to
     *        {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        GE : Greater than or equal.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        GT : Greater than.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If an item contains an AttributeValue element of a
     *        different type than the one provided in the request, the value does not match. For example,
     *        {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not
     *        compare to {"NS":["6", "2", "1"]}.
     *        
     *        

     *        

     *        

     *        NOT_NULL : The attribute exists. NOT_NULL is supported for all data types,
     *        including lists and maps.
     *        
     *        
     *        

     *        This operator tests for the existence of an attribute, not its data type. If the data type of attribute "
     *        a" is null, and you evaluate it using NOT_NULL, the result is a Boolean
     *        true. This result is because the attribute "a" exists; its data type is not
     *        relevant to the NOT_NULL comparison operator.
     *        
     *        
     *        

     *        

     *        NULL : The attribute does not exist. NULL is supported for all data types,
     *        including lists and maps.
     *        
     *        
     *        

     *        This operator tests for the nonexistence of an attribute, not its data type. If the data type of attribute
     *        "a" is null, and you evaluate it using NULL, the result is a Boolean
     *        false. This is because the attribute "a" exists; its data type is not relevant
     *        to the NULL comparison operator.
     *        
     *        
     *        

     *        

     *        CONTAINS : Checks for a subsequence, or value in a set.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If the target attribute of the comparison is of type String, then the
     *        operator checks for a substring match. If the target attribute of the comparison is of type Binary, then
     *        the operator looks for a subsequence of the target that matches the input. If the target attribute of the
     *        comparison is a set ("SS", "NS", or "BS"), then the operator
     *        evaluates to true if it finds an exact match with any member of the set.
     *        
     *        

     *        CONTAINS is supported for lists: When evaluating "a CONTAINS b", "a
     *        " can be a list; however, "b" cannot be a set, a map, or a list.
     *        
     *        
     *        

     *        

     *        NOT_CONTAINS : Checks for absence of a subsequence, or absence of a value in a set.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue element of type String,
     *        Number, or Binary (not a set type). If the target attribute of the comparison is a String, then the
     *        operator checks for the absence of a substring match. If the target attribute of the comparison is Binary,
     *        then the operator checks for the absence of a subsequence of the target that matches the input. If the
     *        target attribute of the comparison is a set ("SS", "NS", or "BS"),
     *        then the operator evaluates to true if it does not find an exact match with any member of the set.
     *        
     *        

     *        NOT_CONTAINS is supported for lists: When evaluating "a NOT CONTAINS b", "a
     *        " can be a list; however, "b" cannot be a set, a map, or a list.
     *        
     *        
     *        

     *        

     *        BEGINS_WITH : Checks for a prefix.
     *        
     *        

     *        AttributeValueList can contain only one AttributeValue of type String or Binary
     *        (not a Number or a set type). The target attribute of the comparison must be of type String or Binary (not
     *        a Number or a set type).
     *        
     *        

     *        

     *        

     *        IN : Checks for matching elements in a list.
     *        
     *        

     *        AttributeValueList can contain one or more AttributeValue elements of type
     *        String, Number, or Binary. These attributes are compared against an existing attribute of an item. If any
     *        elements of the input are equal to the item attribute, the expression evaluates to true.
     *        
     *        
     *        

     *        

     *        BETWEEN : Greater than or equal to the first value, and less than or equal to the second
     *        value.
     *        
     *        

     *        AttributeValueList must contain two AttributeValue elements of the same type,
     *        either String, Number, or Binary (not a set type). A target attribute matches if the target value is
     *        greater than, or equal to, the first element and less than, or equal to, the second element. If an item
     *        contains an AttributeValue element of a different type than the one provided in the request,
     *        the value does not match. For example, {"S":"6"} does not compare to {"N":"6"}.
     *        Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}
     *        
     *        
     * @return Returns a reference to this object so that method calls can be chained together.
     * @see ComparisonOperator
     */

    public ExpectedAttributeValue withComparisonOperator(ComparisonOperator comparisonOperator) {
        this.comparisonOperator = comparisonOperator.toString();
        return this;
    }

    /**
     * 

     * One or more values to evaluate against the supplied attribute. The number of values in the list depends on the
     * ComparisonOperator being used.
     * 
     * 

     * For type Number, value comparisons are numeric.
     * 
     * 

     * String value comparisons for greater than, equals, or less than are based on ASCII character code values. For
     * example, a is greater than A, and a is greater than B. For a
     * list of code values, see http://en.wikipedia
     * .org/wiki/ASCII#ASCII_printable_characters.
     * 
     * 

     * For Binary, DynamoDB treats each byte of the binary data as unsigned when it compares binary values.
     * 
     * 

     * For information on specifying data types in JSON, see JSON Data Format in
     * the Amazon DynamoDB Developer Guide.
     * 
     * 
     * @return One or more values to evaluate against the supplied attribute. The number of values in the list depends
     *         on the ComparisonOperator being used.

     *         

     *         For type Number, value comparisons are numeric.
     *         
     *         

     *         String value comparisons for greater than, equals, or less than are based on ASCII character code values.
     *         For example, a is greater than A, and a is greater than
     *         B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     *         
     *         

     *         For Binary, DynamoDB treats each byte of the binary data as unsigned when it compares binary values.
     *         
     *         

     *         For information on specifying data types in JSON, see JSON Data
     *         Format in the Amazon DynamoDB Developer Guide.
     */

    public java.util.List getAttributeValueList() {
        return attributeValueList;
    }

    /**
     * 

     * One or more values to evaluate against the supplied attribute. The number of values in the list depends on the
     * ComparisonOperator being used.
     * 
     * 

     * For type Number, value comparisons are numeric.
     * 
     * 

     * String value comparisons for greater than, equals, or less than are based on ASCII character code values. For
     * example, a is greater than A, and a is greater than B. For a
     * list of code values, see http://en.wikipedia
     * .org/wiki/ASCII#ASCII_printable_characters.
     * 
     * 

     * For Binary, DynamoDB treats each byte of the binary data as unsigned when it compares binary values.
     * 
     * 

     * For information on specifying data types in JSON, see JSON Data Format in
     * the Amazon DynamoDB Developer Guide.
     * 
     * 
     * @param attributeValueList
     *        One or more values to evaluate against the supplied attribute. The number of values in the list depends on
     *        the ComparisonOperator being used.

     *        

     *        For type Number, value comparisons are numeric.
     *        
     *        

     *        String value comparisons for greater than, equals, or less than are based on ASCII character code values.
     *        For example, a is greater than A, and a is greater than
     *        B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     *        
     *        

     *        For Binary, DynamoDB treats each byte of the binary data as unsigned when it compares binary values.
     *        
     *        

     *        For information on specifying data types in JSON, see JSON Data
     *        Format in the Amazon DynamoDB Developer Guide.
     */

    public void setAttributeValueList(java.util.Collection attributeValueList) {
        if (attributeValueList == null) {
            this.attributeValueList = null;
            return;
        }

        this.attributeValueList = new java.util.ArrayList(attributeValueList);
    }

    /**
     * 

     * One or more values to evaluate against the supplied attribute. The number of values in the list depends on the
     * ComparisonOperator being used.
     * 
     * 

     * For type Number, value comparisons are numeric.
     * 
     * 

     * String value comparisons for greater than, equals, or less than are based on ASCII character code values. For
     * example, a is greater than A, and a is greater than B. For a
     * list of code values, see http://en.wikipedia
     * .org/wiki/ASCII#ASCII_printable_characters.
     * 
     * 

     * For Binary, DynamoDB treats each byte of the binary data as unsigned when it compares binary values.
     * 
     * 

     * For information on specifying data types in JSON, see JSON Data Format in
     * the Amazon DynamoDB Developer Guide.
     * 
     * 

     * NOTE: This method appends the values to the existing list (if any). Use
     * {@link #setAttributeValueList(java.util.Collection)} or {@link #withAttributeValueList(java.util.Collection)} if
     * you want to override the existing values.
     * 
     * 
     * @param attributeValueList
     *        One or more values to evaluate against the supplied attribute. The number of values in the list depends on
     *        the ComparisonOperator being used.

     *        

     *        For type Number, value comparisons are numeric.
     *        
     *        

     *        String value comparisons for greater than, equals, or less than are based on ASCII character code values.
     *        For example, a is greater than A, and a is greater than
     *        B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     *        
     *        

     *        For Binary, DynamoDB treats each byte of the binary data as unsigned when it compares binary values.
     *        
     *        

     *        For information on specifying data types in JSON, see JSON Data
     *        Format in the Amazon DynamoDB Developer Guide.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public ExpectedAttributeValue withAttributeValueList(AttributeValue... attributeValueList) {
        if (this.attributeValueList == null) {
            setAttributeValueList(new java.util.ArrayList(attributeValueList.length));
        }
        for (AttributeValue ele : attributeValueList) {
            this.attributeValueList.add(ele);
        }
        return this;
    }

    /**
     * 

     * One or more values to evaluate against the supplied attribute. The number of values in the list depends on the
     * ComparisonOperator being used.
     * 
     * 

     * For type Number, value comparisons are numeric.
     * 
     * 

     * String value comparisons for greater than, equals, or less than are based on ASCII character code values. For
     * example, a is greater than A, and a is greater than B. For a
     * list of code values, see http://en.wikipedia
     * .org/wiki/ASCII#ASCII_printable_characters.
     * 
     * 

     * For Binary, DynamoDB treats each byte of the binary data as unsigned when it compares binary values.
     * 
     * 

     * For information on specifying data types in JSON, see JSON Data Format in
     * the Amazon DynamoDB Developer Guide.
     * 
     * 
     * @param attributeValueList
     *        One or more values to evaluate against the supplied attribute. The number of values in the list depends on
     *        the ComparisonOperator being used.

     *        

     *        For type Number, value comparisons are numeric.
     *        
     *        

     *        String value comparisons for greater than, equals, or less than are based on ASCII character code values.
     *        For example, a is greater than A, and a is greater than
     *        B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     *        
     *        

     *        For Binary, DynamoDB treats each byte of the binary data as unsigned when it compares binary values.
     *        
     *        

     *        For information on specifying data types in JSON, see JSON Data
     *        Format in the Amazon DynamoDB Developer Guide.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public ExpectedAttributeValue withAttributeValueList(java.util.Collection attributeValueList) {
        setAttributeValueList(attributeValueList);
        return this;
    }

    /**
     * Returns a string representation of this object. This is useful for testing and debugging. Sensitive data will be
     * redacted from this string using a placeholder value.
     *
     * @return A string representation of this object.
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        if (getValue() != null)
            sb.append("Value: ").append(getValue()).append(",");
        if (getExists() != null)
            sb.append("Exists: ").append(getExists()).append(",");
        if (getComparisonOperator() != null)
            sb.append("ComparisonOperator: ").append(getComparisonOperator()).append(",");
        if (getAttributeValueList() != null)
            sb.append("AttributeValueList: ").append(getAttributeValueList());
        sb.append("}");
        return sb.toString();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;

        if (obj instanceof ExpectedAttributeValue == false)
            return false;
        ExpectedAttributeValue other = (ExpectedAttributeValue) obj;
        if (other.getValue() == null ^ this.getValue() == null)
            return false;
        if (other.getValue() != null && other.getValue().equals(this.getValue()) == false)
            return false;
        if (other.getExists() == null ^ this.getExists() == null)
            return false;
        if (other.getExists() != null && other.getExists().equals(this.getExists()) == false)
            return false;
        if (other.getComparisonOperator() == null ^ this.getComparisonOperator() == null)
            return false;
        if (other.getComparisonOperator() != null && other.getComparisonOperator().equals(this.getComparisonOperator()) == false)
            return false;
        if (other.getAttributeValueList() == null ^ this.getAttributeValueList() == null)
            return false;
        if (other.getAttributeValueList() != null && other.getAttributeValueList().equals(this.getAttributeValueList()) == false)
            return false;
        return true;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int hashCode = 1;

        hashCode = prime * hashCode + ((getValue() == null) ? 0 : getValue().hashCode());
        hashCode = prime * hashCode + ((getExists() == null) ? 0 : getExists().hashCode());
        hashCode = prime * hashCode + ((getComparisonOperator() == null) ? 0 : getComparisonOperator().hashCode());
        hashCode = prime * hashCode + ((getAttributeValueList() == null) ? 0 : getAttributeValueList().hashCode());
        return hashCode;
    }

    @Override
    public ExpectedAttributeValue clone() {
        try {
            return (ExpectedAttributeValue) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new IllegalStateException("Got a CloneNotSupportedException from Object.clone() " + "even though we're Cloneable!", e);
        }
    }

    @com.amazonaws.annotation.SdkInternalApi
    @Override
    public void marshall(ProtocolMarshaller protocolMarshaller) {
        com.amazonaws.services.dynamodbv2.model.transform.ExpectedAttributeValueMarshaller.getInstance().marshall(this, protocolMarshaller);
    }
}