Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014-2015 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.document.internal;
 
 import static com.amazonaws.util.BinaryUtils.copyAllBytesFrom;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
Internal utilities. Not meant for general use. May change without notice.
 
 public enum InternalUtils {
     ;

    
Returns a non-null list of Item's given the low level list of item information.
 
     public static List<ItemtoItemList(List<Map<StringAttributeValue>> items) {
         if (items == null)
             return Collections.emptyList();
         List<Itemresult = new ArrayList<Item>(items.size());
         for (Map<StringAttributeValueitem : items)
             result.add(Item.fromMap(toSimpleMapValue(item)));
         return result;
     }

    
Converts an Item into the low-level representation; or null if the input is null.
 
     public static Map<StringAttributeValuetoAttributeValues(Item item) {
         if (item == null)
             return null;
         // row with multiple attributes
         Map<StringAttributeValueresult = new LinkedHashMap<StringAttributeValue>();
         for (Map.Entry<StringObjectentry : item.attributes())
             result.put(entry.getKey(), toAttributeValue(entry.getValue()));
         return result;
     }

    
Converts a map of string to simple objects into the low-level representation; or null if the input is null.
 
     public static Map<StringAttributeValuefromSimpleMap(
             Map<StringObjectmap) {
         if (map == null)
             return null;
         // row with multiple attributes
         Map<StringAttributeValueresult = new LinkedHashMap<StringAttributeValue>();
         for (Map.Entry<StringObjectentry : map.entrySet())
             result.put(entry.getKey(), toAttributeValue(entry.getValue()));
         return result;
     }

    
Converts a list of AttributeUpdate into the low-level representation; or null if the input is null.
 
             List<AttributeUpdateattributesToUpdate) {
         if (attributesToUpdate == null)
            return null;
        for (AttributeUpdate attribute : attributesToUpdate) {
            AttributeValueUpdate attributeToUpdate = new AttributeValueUpdate()
                    .withAction(attribute.getAction());
            if (attribute.getValue() != null) {
                attributeToUpdate.withValue(toAttributeValue(attribute
                        .getValue()));
            } else if (attribute.getAttributeValues() != null) {
                attributeToUpdate.withValue(toAttributeValue(attribute
                        .getAttributeValues()));
            }
            result.put(attribute.getAttributeName(), attributeToUpdate);
        }
        return result;
    }

    
Converts a simple value into the low-level <AttributeValue/code> representation.

Parameters:
value the given value which can be one of the followings:
  • String
  • Set<String>
  • Number (including any subtypes and primitive types)
  • Set<Number>
  • byte[]
  • Set<byte[]>
  • ByteBuffer
  • Set<ByteBuffer>
  • Boolean or boolean
  • null
  • Map<String,T>, where T can be any type on this list but must not induce any circular reference
  • List<T>, where T can be any type on this list but must not induce any circular reference
Returns:
a non-null low level representation of the input object value
Throws:
java.lang.UnsupportedOperationException if the input object type is not supported
    public static AttributeValue toAttributeValue(Object value) {
        AttributeValue result = new AttributeValue();
        if (value == null) {
            return result.withNULL(.);
        } else if (value instanceof Boolean) {
            return result.withBOOL((Boolean)value);
        } else if (value instanceof String) {
            return result.withS((Stringvalue);
        } else if (value instanceof BigDecimal) {
            BigDecimal bd = (BigDecimalvalue;
            return result.withN(bd.toPlainString());
        } else if (value instanceof Number) {
            return result.withN(value.toString());
        } else if (value instanceof byte[]) {
            return result.withB(ByteBuffer.wrap((byte[]) value));
        } else if (value instanceof ByteBuffer) {
            return result.withB((ByteBuffervalue);
        } else if (value instanceof Set) {
            // default to an empty string set if there is no element
            @SuppressWarnings("unchecked")
            Set<Objectset = (Set<Object>) value;
            if (set.size() == 0) {
                result.setSS(new LinkedHashSet<String>());
                return result;
            }
            Object element = set.iterator().next();
            if (element instanceof String) {
                @SuppressWarnings("unchecked")
                Set<Stringss = (Set<String>) value;
                result.setSS(new ArrayList<String>(ss));
            } else if (element instanceof Number) {
                @SuppressWarnings("unchecked")
                Set<Numberin = (Set<Number>) value;
                List<Stringout = new ArrayList<String>(set.size());
                for (Number n : in) {
                    BigDecimal bd = InternalUtils.toBigDecimal(n);
                    out.add(bd.toPlainString());
                }
                result.setNS(out);
            } else if (element instanceof byte[]) {
                @SuppressWarnings("unchecked")
                Set<byte[]> in = (Set<byte[]>) value;
                List<ByteBufferout = new ArrayList<ByteBuffer>(set.size());
                for (byte[] buf : in) {
                    out.add(ByteBuffer.wrap(buf));
                }
                result.setBS(out);
            } else if (element instanceof ByteBuffer) {
                @SuppressWarnings("unchecked")
                Set<ByteBufferbs = (Set<ByteBuffer>) value;
                result.setBS(bs);
            } else {
                throw new UnsupportedOperationException("element type: "
                        + element.getClass());
            }
        } else if (value instanceof List) {
            @SuppressWarnings("unchecked")
            List<Objectin = (List<Object>) value;
            List<AttributeValueout = new ArrayList<AttributeValue>();
            for (Object v : in) {
                out.add(toAttributeValue(v));
            }
            result.setL(out);
        } else if (value instanceof Map) {
            @SuppressWarnings("unchecked")
            Map<StringObjectin = (Map<StringObject>) value;
            if (in.size() > 0) {
                for (Map.Entry<StringObjecte : in.entrySet()) {
                    result.addMEntry(e.getKey(), toAttributeValue(e.getValue()));
                }
            } else {    // empty map
                result.setM(new LinkedHashMap<String,AttributeValue>());
            }
        } else {
            throw new UnsupportedOperationException("value type: "
                    + value.getClass());
        }
        return result;
    }

    
Converts a list of low-level AttributeValue into a list of simple values. Each value in the returned list can be one of the followings:
  • String
  • Set<String>
  • Number (including any subtypes and primitive types)
  • Set<Number>
  • byte[]
  • Set<byte[]>
  • ByteBuffer
  • Set<ByteBuffer>
  • Boolean or boolean
  • null
  • Map<String,T>, where T can be any type on this list but must not induce any circular reference
  • List<T>, where T can be any type on this list but must not induce any circular reference
    public static List<ObjecttoSimpleList(List<AttributeValueattrValues) {
        if (attrValues == null)
            return null;
        List<Objectresult = new ArrayList<Object>(attrValues.size());
        for (AttributeValue attrValue : attrValues) {
            Object value = toSimpleValue(attrValue);
            result.add(value);
        }
        return result;
    }

    
Convenient method to convert a list of low-level AttributeValue into a list of values of the same type T. Each value in the returned list can be one of the followings:
  • String
  • Set<String>
  • Number (including any subtypes and primitive types)
  • Set<Number>
  • byte[]
  • Set<byte[]>
  • ByteBuffer
  • Set<ByteBuffer>
  • Boolean or boolean
  • null
  • Map<String,T>, where T can be any type on this list but must not induce any circular reference
  • List<T>, where T can be any type on this list but must not induce any circular reference
    public static <T> List<T> toSimpleListValue(List<AttributeValuevalues) {
        if (values == null) {
            return null;
        }
        List<T> result = new ArrayList<T>(values.size());
        for (AttributeValue v : values) {
            T t = toSimpleValue(v);
            result.add(t);
        }
        return result;
    }
    public static <T> Map<String, T> toSimpleMapValue(
            Map<StringAttributeValuevalues) {
        if (values == null) {
            return null;
        }
        Map<String, T> result = new LinkedHashMap<String, T>(values.size());
        for (Map.Entry<StringAttributeValueentry : values.entrySet()) {
            T t = toSimpleValue(entry.getValue());
            result.put(entry.getKey(), t);
        }
        return result;
    }

    
Returns the string representation of the given value; or null if the value is null. For BigDecimal it will be the string representation without an exponent field.
    public static String valToString(Object val) {
        if (val instanceof BigDecimal) {
            BigDecimal bd = (BigDecimal)val;
            return bd.toPlainString();
        }
        if (val == null)
            return null;
        if (val instanceof String
        ||  val instanceof Boolean
        ||  val instanceof Number)
            return val.toString();
        throw new IncompatibleTypeException("Cannot convert " + val.getClass() + " into a string");
    }

    
Converts a low-level AttributeValue into a simple value, which can be one of the followings:
  • String
  • Set<String>
  • Number (including any subtypes and primitive types)
  • Set<Number>
  • byte[]
  • Set<byte[]>
  • ByteBuffer
  • Set<ByteBuffer>
  • Boolean or boolean
  • null
  • Map<String,T>, where T can be any type on this list but must not induce any circular reference
  • List<T>, where T can be any type on this list but must not induce any circular reference

Throws:
java.lang.IllegalArgumentException if an empty AttributeValue value is specified
    static <T> T toSimpleValue(AttributeValue value) {
        if (value == null) {
            return null;
        }
        if (..equals(value.getNULL())) {
            return null;
        } else if (..equals(value.getNULL())) {
            throw new UnsupportedOperationException("False-NULL is not supported in DynamoDB");
        } else if (value.getBOOL() != null) {
            @SuppressWarnings("unchecked")
            T t = (T) value.getBOOL();
            return t;
        } else if (value.getS() != null) {
            @SuppressWarnings("unchecked")
            T t = (T) value.getS();
            return t;
        } else if (value.getN() != null) {
            @SuppressWarnings("unchecked")
            T t = (T) new BigDecimal(value.getN());
            return t;
        } else if (value.getB() != null) {
            @SuppressWarnings("unchecked")
            T t = (T) copyAllBytesFrom(value.getB());
            return t;
        } else if (value.getSS() != null) {
            @SuppressWarnings("unchecked")
            T t = (T) new LinkedHashSet<String>(value.getSS());
            return t;
        } else if (value.getNS() != null) {
            Set<BigDecimalset = new LinkedHashSet<BigDecimal>(value.getNS().size());
            for (String s : value.getNS()) {
                set.add(new BigDecimal(s));
            }
            @SuppressWarnings("unchecked")
            T t = (T) set;
            return t;
        } else if (value.getBS() != null) {
            Set<byte[]> set = new LinkedHashSet<byte[]>(value.getBS().size());
            for (ByteBuffer bb : value.getBS()) {
                set.add(copyAllBytesFrom(bb));
            }
            @SuppressWarnings("unchecked")
            T t = (T) set;
            return t;
        } else if (value.getL() != null) {
            @SuppressWarnings("unchecked")
            T t = (T) toSimpleList(value.getL());
            return t;
        } else if (value.getM() != null) {
            @SuppressWarnings("unchecked")
            T t = (T) toSimpleMapValue(value.getM());
            return t;
        } else {
            throw new IllegalArgumentException(
                    "Attribute value must not be empty: " + value);
        }
    }

    
Returns the minimum of the two input integers taking null into account. Returns null if both integers are null. Otherwise, a null Integer is treated as infinity.
    public static Integer minimum(Integer oneInteger two) {
        if (one == null) {
            return two;
        } else if (two == null) {
            return one;
        } else if (one < two) {
            return one;
        } else {
            return two;
        }
    }

    
Returns the low level representation of a collection of Expected.
            Collection<ExpectedexpectedSet) {
        if (expectedSet == null)
            return null;
        Map<StringExpectedAttributeValueexpectedMap =
                new LinkedHashMap<StringExpectedAttributeValue>();
        for (Expected expected : expectedSet) {
            final String attr = expected.getAttribute();
            final Object[] values = expected.getValues();
            ExpectedAttributeValue eav = new ExpectedAttributeValue();
            if (values != null) {
                if (values.length > 0) {
                    // convert from list of object values to list of AttributeValues
                    AttributeValue[] avs = InternalUtils.toAttributeValues(values);
                    eav.withAttributeValueList(avs);
                } else {
                    throw new IllegalStateException("Bug!");
                }
            }
            ComparisonOperator op = expected.getComparisonOperator();
            if (op == null) {
                throw new IllegalArgumentException(
                        "Comparison operator for attribute " + expected.getAttribute()
                                + " must be specified");
            }
            eav.withComparisonOperator(op);
            expectedMap.put(attreav);
        }
        if (expectedSet.size() != expectedMap.size())
            throw new IllegalArgumentException("duplicates attribute names not allowed in input");
        return Collections.unmodifiableMap(expectedMap);
    }

    
Returns the low level representation of a collection of Filter.
    public static Map<StringConditiontoAttributeConditionMap(Collection<? extends Filter<?>> filters) {
        if (filters == null)
            return null;
        Map<StringConditionconditionMap = new LinkedHashMap<StringCondition>();
        for (Filter<?> filter : filters) {
            final String attr = filter.getAttribute();
            final Object[] values = filter.getValues();
            Condition condition = new Condition();
            if (values != null) {
                if (values.length > 0) {
                    // convert from list of object values to list of AttributeValues
                    AttributeValue[] avs = InternalUtils.toAttributeValues(values);
                    condition.withAttributeValueList(avs);
                } else {
                    throw new IllegalStateException("Bug!");
                }
            }
            ComparisonOperator op = filter.getComparisonOperator();
            if (op == null) {
                throw new IllegalArgumentException(
                        "Comparison operator for attribute " + filter.getAttribute()
                                + " must be specified");
            }
            condition.withComparisonOperator(op);
            conditionMap.put(attrcondition);
        }
        if (filters.size() != conditionMap.size())
            throw new IllegalArgumentException("duplicates attribute names not allowed in input");
        return Collections.unmodifiableMap(conditionMap);
    }

    
Converts the input array of values into an array of low level representation of those values. A value in the input array can be one of the followings:
  • String
  • Set<String>
  • Number (including any subtypes and primitive types)
  • Set<Number>
  • byte[]
  • Set<byte[]>
  • ByteBuffer
  • Set<ByteBuffer>
  • Boolean or boolean
  • null
  • Map<String,T>, where T can be any type on this list but must not induce any circular reference
  • List<T>, where T can be any type on this list but must not induce any circular reference
    public static AttributeValue[] toAttributeValues(Object[] values) {
        AttributeValue[] attrValues = new AttributeValue[values.length];
        for (int i=0; i < values.lengthi++)
            attrValues[i] = InternalUtils.toAttributeValue(values[i]);
        return attrValues;
    }

    
Converts the specified primary key into the low-level representation.
    public static Map<StringAttributeValuetoAttributeValueMap(
            Collection<KeyAttributeprimaryKey) {
        if (primaryKey == null)
            return null;
        Map<StringAttributeValuekeys = new LinkedHashMap<StringAttributeValue>();
        for (KeyAttribute keyAttr : primaryKey)
            keys.put(keyAttr.getName(),
                    InternalUtils.toAttributeValue(keyAttr.getValue()));
        return Collections.unmodifiableMap(keys);
    }

    
Converts the specified primary key into the low-level representation.
    public static Map<StringAttributeValuetoAttributeValueMap(
            PrimaryKey primaryKey) {
        if (primaryKey == null)
            return null;
        return toAttributeValueMap(primaryKey.getComponents());
    }

    
Converts the specified primary key into the low-level representation.
    public static Map<StringAttributeValuetoAttributeValueMap(
            KeyAttribute ... primaryKey) {
        if (primaryKey == null)
            return null;
        return toAttributeValueMap(Arrays.asList(primaryKey));
    }

    
Converts a number into BigDecimal representation.
    public static BigDecimal toBigDecimal(Number n) {
        if (n instanceof BigDecimal)
            return (BigDecimal)n;
        return new BigDecimal(n.toString());
    }
    public static Set<BigDecimaltoBigDecimalSet(Number ... val) {
        Set<BigDecimalset = new LinkedHashSet<BigDecimal>(val.length);
        for (Number nval)
            set.add(InternalUtils.toBigDecimal(n));
        return set;
    }
    public static Set<BigDecimaltoBigDecimalSet(Set<Numbervals) {
        Set<BigDecimalset = new LinkedHashSet<BigDecimal>(vals.size());
        for (Number nvals)
            set.add(InternalUtils.toBigDecimal(n));
        return set;
    }

    
Append the custom user-agent string.
    public static <X extends AmazonWebServiceRequest> X applyUserAgent(X request) {
        final String USER_AGENT = "dynamodb-table-api/" + VersionInfoUtils.getVersion();
        request.getRequestClientOptions().appendUserAgent(USER_AGENT);
        return request;
    }
    public static void rejectNullValue(Object val) {
        if (val == null)
            throw new IllegalArgumentException("Input value must not be null");
    }
    public static void rejectNullInput(Object input) {
        if (input == null)
            throw new IllegalArgumentException("Input must not be null");
    }
    public static void rejectEmptyInput(Object[] input) {
        if (input.length == 0)
            throw new IllegalArgumentException("At least one input must be specified");
    }
    public static void rejectNullOrEmptyInput(Object[] input) {
        rejectNullInput(input);
        rejectEmptyInput(input);
    }
    public static void checkInvalidAttrName(String attrName) {
        if (attrName == null || attrName.trim().length() == 0)
            throw new IllegalArgumentException("Attribute name must not be null or empty");
    }
    public static void checkInvalidAttribute(String attrNameObject val) {
        checkInvalidAttrName(attrName);
        rejectNullValue(val);
    }
New to GrepCode? Check out our FAQ X