• Home
• com.amazonaws
• aws-java-sdk-osgi
• 1.11.21
• source code
• L.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.xspec.L Maven / Gradle / Ivy

/*
 * Copyright 2015-2016 Amazon Technologies, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *    http://aws.amazon.com/apache2.0
 *
 * 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.xspec;

import java.util.Arrays;
import java.util.List;

import org.apache.http.annotation.Immutable;

import com.amazonaws.annotation.Beta;

/**
 * A path operand that refers to a list attribute in DynamoDB; used for building expressions.
 * 

 * Use {@link ExpressionSpecBuilder#L(String)} to instantiate this class.
 */
@Beta
@Immutable
public final class L extends PathOperand {

    L(String path) {
        super(path);
    }

    /**
     * Returns a SetAction for adding the value of evaluating the
     * specified ListAppend function as an attribute to an item. If
     * this attribute already exists, it will be replaced by the new value.
     */
    public SetAction set(ListAppendFunction listAppendFunction) {
        return new SetAction(this, listAppendFunction);
    }

    public FunctionCondition contains(Object value) {
        return new FunctionCondition("contains", this,
                new LiteralOperand(value));
    }

    public ComparatorCondition eq(FunctionOperand value) {
        return new ComparatorCondition("=", this, value);
    }

    public ComparatorCondition eq(L that) {
        return new ComparatorCondition("=", this, that);
    }

    public ComparatorCondition ne(FunctionOperand value) {
        return new ComparatorCondition("<>", this, value);
    }

    public ComparatorCondition ne(L that) {
        return new ComparatorCondition("<>", this, that);
    }

    public IfNotExistsFunction ifNotExists(L that) {
        return new IfNotExistsFunction(this, that);
    }

    public IfNotExistsFunction ifNotExists(Object... defaultValues) {
        return new IfNotExistsFunction(this, new LiteralOperand(
                Arrays.asList(defaultValues)));
    }

    /**
     * Returns an ListAppend for building expression that involves
     * a list_append(operand, operand) function for the purpose of adding the
     * specified values to the current list attribute.
     * 
     * @param values
     *            the specified values to be added to the current list
     *            attribute.
     */
    public ListAppendFunction listAppend(Object... values) {
        return new ListAppendFunction(this, new LiteralOperand(
                Arrays.asList(values)));
    }

    /**
     * Returns an ListAppend for building expression that involves
     * a list_append(operand, operand) function for the purpose of adding the
     * specified list of values to that of the current list attribute.
     * 
     * @param values
     *            the specified list of values to be added to the current list
     *            attribute.
     */
    public ListAppendFunction listAppend(List values) {
        return new ListAppendFunction(this, new LiteralOperand(values));
    }

    /**
     * Returns an ListAppend for building expression that involves
     * a list_append(operand, operand) function for the purpose of adding the
     * values of the specified list attribute to the current list attribute.
     * 
     * @param that
     *            the specified list attribute whose values will be added to the
     *            current list attribute.
     */
    public ListAppendFunction listAppend(L that) {
        return new ListAppendFunction(this, that);
    }

    /**
     * Returns a SetAction object used for building update
     * expression. If the attribute referred to by this path operand doesn't
     * exist, the returned object represents adding the attribute value of the
     * specified source path operand to an item. If the current attribute
     * already exists, the returned object represents the value replacement of
     * the current attribute by the attribute value of the specified source path
     * operand.
     */
    public SetAction set(L source) {
        return new SetAction(this, source);
    }

    /**
     * Returns a SetAction object used for building update
     * expression. If the attribute referred to by this path operand doesn't
     * exist, the returned object represents adding the specified value as an
     * attribute to an item. If the attribute referred to by this path operand
     * already exists, the returned object represents the value replacement of
     * the current attribute by the specified value.
     */
    public SetAction set(List value) {
        return new SetAction(this, new LiteralOperand(value));
    }

    /**
     * Returns a SetAction object used for building update
     * expression. If the attribute referred to by this path operand doesn't
     * exist, the returned object represents adding the value of evaluating the
     * specified IfNotExists function as an attribute to an item.
     * If the attribute referred to by this path operand already exists, the
     * returned object represents the value replacement of the current attribute
     * by the value of evaluating the specified IfNotExists
     * function.
     */
    public SetAction set(IfNotExistsFunction ifNotExistsFunction) {
        return new SetAction(this, ifNotExistsFunction);
    }

    /**
     * Returns a comparator condition (that evaluates to true if the attribute value
     * referred to by this path operand is equal to the specified value) for
     * building condition expression.
     */
    public ComparatorCondition eq(List value) {
        return new ComparatorCondition("=", this, new LiteralOperand(value));
    }

    /**
     * Returns a comparator condition (that evaluates to true if the attribute value
     * referred to by this path operand is not equal to that of the specified
     * path operand) for building condition expression.
     */
    public ComparatorCondition ne(List value) {
        return new ComparatorCondition("<>", this, new LiteralOperand(value));
    }

    /**
     * Returns an IfNotExists object which represents an if_not_exists(path, operand) function call where path refers to that
     * of the current path operand; used for building expressions.
     * 
     * 
     * "if_not_exists (path, operand) – If the item does not contain an attribute 
     * at the specified path, then if_not_exists evaluates to operand; otherwise, 
     * it evaluates to path. You can use this function to avoid overwriting an 
     * attribute already present in the item."
     * 
     * 
     * @param defaultValue
     *            the default value that will be used as the operand to the
     *            if_not_exists function call.
     */
    public IfNotExistsFunction ifNotExists(List defaultValue) {
        return new IfNotExistsFunction(this, new LiteralOperand(defaultValue));
    }
}