Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *      Copyright (C) 2012 DataStax 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://www.apache.org/licenses/LICENSE-2.0
   *
  *   Unless required by applicable law or agreed to in writing, software
  *   distributed under the License 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.datastax.driver.core;
 
 import java.util.*;
 
 
Implementation of a Row backed by an ArrayList.
 
 class ArrayBackedRow implements Row {
 
     private final ColumnDefinitions metadata;
     private final List<ByteBufferdata;
 
     private ArrayBackedRow(ColumnDefinitions metadataList<ByteBufferdata) {
         this. = metadata;
         this. = data;
     }
 
     static Row fromData(ColumnDefinitions metadataList<ByteBufferdata) {
         if (data == null)
             return null;
 
         return new ArrayBackedRow(metadatadata);
     }
 
         return ;
     }
 
     public boolean isNull(int i) {
         .checkBounds(i);
         return .get(i) == null;
     }
 
     public boolean isNull(String name) {
         return isNull(.getIdx(name));
     }
 
     public boolean getBool(int i) {
         .checkType(i..);
 
         ByteBuffer value = .get(i);
         if (value == null || value.remaining() == 0)
             return false;
 
         return ..compose(value);
     }
 
     public boolean getBool(String name) {
         return getBool(.getIdx(name));
     }
 
     public int getInt(int i) {
         .checkType(i..);
 
         ByteBuffer value = .get(i);
         if (value == null || value.remaining() == 0)
             return 0;
 
         return ..compose(value);
     }
 
     public int getInt(String name) {
         return getInt(.getIdx(name));
     }
 
     public long getLong(int i) {
 
         ByteBuffer value = .get(i);
         if (value == null || value.remaining() == 0)
             return 0L;
 
         return ..compose(value);
     }
 
     public long getLong(String name) {
        return getLong(.getIdx(name));
    }
    public Date getDate(int i) {
        ByteBuffer value = .get(i);
        if (value == null || value.remaining() == 0)
            return null;
        return ..compose(value);
    }
    public Date getDate(String name) {
        return getDate(.getIdx(name));
    }
    public float getFloat(int i) {
        .checkType(i..);
        ByteBuffer value = .get(i);
        if (value == null || value.remaining() == 0)
            return 0.0f;
        return ..compose(value);
    }
    public float getFloat(String name) {
        return getFloat(.getIdx(name));
    }
    public double getDouble(int i) {
        .checkType(i..);
        ByteBuffer value = .get(i);
        if (value == null || value.remaining() == 0)
            return 0.0;
        return ..compose(value);
    }
    public double getDouble(String name) {
        return getDouble(.getIdx(name));
    }
    public ByteBuffer getBytesUnsafe(int i) {
        .checkBounds(i);
        ByteBuffer value = .get(i);
        if (value == null)
            return null;
        return value.duplicate();
    }
    public ByteBuffer getBytesUnsafe(String name) {
        return getBytesUnsafe(.getIdx(name));
    }
    public ByteBuffer getBytes(int i) {
        .checkType(i..);
        return getBytesUnsafe(i);
    }
    public ByteBuffer getBytes(String name) {
        return getBytes(.getIdx(name));
    }
    public String getString(int i) {
        DataType.Name type = .checkType(i..,
                                                   ..,
                                                   ..);
        ByteBuffer value = .get(i);
        if (value == null)
            return null;
        return type == ..
             ? ..compose(value)
             : ..compose(value);
    }
    public String getString(String name) {
        return getString(.getIdx(name));
    }
    public BigInteger getVarint(int i) {
        .checkType(i..);
        ByteBuffer value = .get(i);
        if (value == null || value.remaining() == 0)
            return null;
        return ..compose(value);
    }
    public BigInteger getVarint(String name) {
        return getVarint(.getIdx(name));
    }
    public BigDecimal getDecimal(int i) {
        .checkType(i..);
        ByteBuffer value = .get(i);
        if (value == null || value.remaining() == 0)
            return null;
        return ..compose(value);
    }
    public BigDecimal getDecimal(String name) {
        return getDecimal(.getIdx(name));
    }
    public UUID getUUID(int i) {
        ByteBuffer value = .get(i);
        if (value == null || value.remaining() == 0)
            return null;
        return type == ..
             ? ..compose(value)
             : ..compose(value);
    }
    public UUID getUUID(String name) {
        return getUUID(.getIdx(name));
    }
    public InetAddress getInet(int i) {
        .checkType(i..);
        ByteBuffer value = .get(i);
        if (value == null || value.remaining() == 0)
            return null;
        return ..compose(value);
    }
    public InetAddress getInet(String name) {
        return getInet(.getIdx(name));
    }
    @SuppressWarnings("unchecked")
    public <T> List<T> getList(int iClass<T> elementsClass) {
        DataType type = .getType(i);
        if (type.getName() != ..)
            throw new InvalidTypeException(String.format("Column %s is not of list type".getName(i)));
        Class<?> expectedClass = type.getTypeArguments().get(0).getName().;
        if (!elementsClass.isAssignableFrom(expectedClass))
            throw new InvalidTypeException(String.format("Column %s is a list of %s (CQL type %s), cannot be retrieve as a list of %s".getName(i), expectedClasstypeelementsClass));
        ByteBuffer value = .get(i);
        if (value == null)
            return Collections.<T>emptyList();
        // TODO: we could avoid the getCodec call if we kept a reference to the original message.
        return Collections.unmodifiableList(Codec.<List<T>>getCodec(type).compose(value));
    }
    public <T> List<T> getList(String nameClass<T> elementsClass) {
        return getList(.getIdx(name), elementsClass);
    }
    @SuppressWarnings("unchecked")
    public <T> Set<T> getSet(int iClass<T> elementsClass) {
        DataType type = .getType(i);
        if (type.getName() != ..)
            throw new InvalidTypeException(String.format("Column %s is not of set type".getName(i)));
        Class<?> expectedClass = type.getTypeArguments().get(0).getName().;
        if (!elementsClass.isAssignableFrom(expectedClass))
            throw new InvalidTypeException(String.format("Column %s is a set of %s (CQL type %s), cannot be retrieve as a set of %s".getName(i), expectedClasstypeelementsClass));
        ByteBuffer value = .get(i);
        if (value == null)
            return Collections.<T>emptySet();
        return Collections.unmodifiableSet(Codec.<Set<T>>getCodec(type).compose(value));
    }
    public <T> Set<T> getSet(String nameClass<T> elementsClass) {
        return getSet(.getIdx(name), elementsClass);
    }
    @SuppressWarnings("unchecked")
    public <K, V> Map<K, V> getMap(int iClass<K> keysClassClass<V> valuesClass) {
        DataType type = .getType(i);
        if (type.getName() != ..)
            throw new InvalidTypeException(String.format("Column %s is not of map type".getName(i)));
        Class<?> expectedKeysClass = type.getTypeArguments().get(0).getName().;
        Class<?> expectedValuesClass = type.getTypeArguments().get(1).getName().;
        if (!keysClass.isAssignableFrom(expectedKeysClass) || !valuesClass.isAssignableFrom(expectedValuesClass))
            throw new InvalidTypeException(String.format("Column %s is a map of %s->%s (CQL type %s), cannot be retrieve as a map of %s->%s".getName(i), expectedKeysClassexpectedValuesClasstypekeysClassvaluesClass));
        ByteBuffer value = .get(i);
        if (value == null)
            return Collections.<K, V>emptyMap();
        return Collections.unmodifiableMap(Codec.<Map<K, V>>getCodec(type).compose(value));
    }
    public <K, V> Map<K, V> getMap(String nameClass<K> keysClassClass<V> valuesClass) {
        return getMap(.getIdx(name), keysClassvaluesClass);
    }
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Row[");
        for (int i = 0; i < .size(); i++) {
            if (i != 0)
                sb.append(", ");
            ByteBuffer bb = .get(i);
            if (bb == null)
                sb.append("NULL");
            else
                sb.append(Codec.getCodec(.getType(i)).getString(bb));
        }
        sb.append("]");
        return sb.toString();
    }
New to GrepCode? Check out our FAQ X