devboxos
diff --git a/‎driver-core/src/main/java/com/datastax/driver/core/AbstractAddressableByIndexData.java‎
Lines changed: 20 additions & 0 deletions b/‎driver-core/src/main/java/com/datastax/driver/core/AbstractAddressableByIndexData.java‎
Lines changed: 20 additions & 0 deletions
@@ -38,40 +38,48 @@ protected T setValue(int i, ByteBuffer value) {
         return (T) this;
     }
 
+    @Override
     protected ByteBuffer getValue(int i) {
         return values[i];
     }
 
+    @Override
     public T setBool(int i, boolean v) {
         checkType(i, DataType.Name.BOOLEAN);
         return setValue(i, TypeCodec.booleanCodec.serializeNoBoxing(v));
     }
 
+    @Override
     public T setInt(int i, int v) {
         checkType(i, DataType.Name.INT);
         return setValue(i, TypeCodec.intCodec.serializeNoBoxing(v));
     }
 
+    @Override
     public T setLong(int i, long v) {
         checkType(i, DataType.Name.BIGINT, DataType.Name.COUNTER);
         return setValue(i, TypeCodec.longCodec.serializeNoBoxing(v));
     }
 
+    @Override
     public T setDate(int i, Date v) {
         checkType(i, DataType.Name.TIMESTAMP);
         return setValue(i, v == null ? null : TypeCodec.dateCodec.serialize(v));
     }
 
+    @Override
     public T setFloat(int i, float v) {
         checkType(i, DataType.Name.FLOAT);
         return setValue(i, TypeCodec.floatCodec.serializeNoBoxing(v));
     }
 
+    @Override
     public T setDouble(int i, double v) {
         checkType(i, DataType.Name.DOUBLE);
         return setValue(i, TypeCodec.doubleCodec.serializeNoBoxing(v));
     }
 
+    @Override
     public T setString(int i, String v) {
         DataType.Name type = checkType(i, DataType.Name.VARCHAR, DataType.Name.TEXT, DataType.Name.ASCII);
         switch (type) {
@@ -85,25 +93,30 @@ public T setString(int i, String v) {
         }
     }
 
+    @Override
     public T setBytes(int i, ByteBuffer v) {
         checkType(i, DataType.Name.BLOB);
         return setBytesUnsafe(i, v);
     }
 
+    @Override
     public T setBytesUnsafe(int i, ByteBuffer v) {
         return setValue(i, v == null ? null : v.duplicate());
     }
 
+    @Override
     public T setVarint(int i, BigInteger v) {
         checkType(i, DataType.Name.VARINT);
         return setValue(i, v == null ? null : TypeCodec.bigIntegerCodec.serialize(v));
     }
 
+    @Override
     public T setDecimal(int i, BigDecimal v) {
         checkType(i, DataType.Name.DECIMAL);
         return setValue(i, v == null ? null : TypeCodec.decimalCodec.serialize(v));
     }
 
+    @Override
     public T setUUID(int i, UUID v) {
         DataType.Name type = checkType(i, DataType.Name.UUID, DataType.Name.TIMEUUID);
 
@@ -118,11 +131,13 @@ public T setUUID(int i, UUID v) {
                 : setValue(i, TypeCodec.timeUuidCodec.serialize(v));
     }
 
+    @Override
     public T setInet(int i, InetAddress v) {
         checkType(i, DataType.Name.INET);
         return setValue(i, v == null ? null : TypeCodec.inetCodec.serialize(v));
     }
 
+    @Override
     public <E> T setList(int i, List<E> v) {
         DataType type = getType(i);
         if (type.getName() != DataType.Name.LIST)
@@ -143,6 +158,7 @@ public <E> T setList(int i, List<E> v) {
         return setValue(i, type.codec(protocolVersion).serialize(v));
     }
 
+    @Override
     public <K, V> T setMap(int i, Map<K, V> v) {
         DataType type = getType(i);
         if (type.getName() != DataType.Name.MAP)
@@ -165,6 +181,7 @@ public <K, V> T setMap(int i, Map<K, V> v) {
         return setValue(i, type.codec(protocolVersion).serialize(v));
     }
 
+    @Override
     public <E> T setSet(int i, Set<E> v) {
         DataType type = getType(i);
         if (type.getName() != DataType.Name.SET)
@@ -184,6 +201,7 @@ public <E> T setSet(int i, Set<E> v) {
         return setValue(i, type.codec(protocolVersion).serialize(v));
     }
 
+    @Override
     public T setUDTValue(int i, UDTValue v) {
         DataType type = getType(i);
         if (type.getName() != DataType.Name.UDT)
@@ -196,6 +214,7 @@ public T setUDTValue(int i, UDTValue v) {
         return setValue(i, type.codec(ProtocolVersion.V3).serialize(v));
     }
 
+    @Override
     public T setTupleValue(int i, TupleValue v) {
         DataType type = getType(i);
         if (type.getName() != DataType.Name.TUPLE)
@@ -208,6 +227,7 @@ public T setTupleValue(int i, TupleValue v) {
         return setValue(i, type.codec(ProtocolVersion.V3).serialize(v));
     }
 
+    @Override
     public T setToNull(int i) {
         return setValue(i, null);
     }
Original file line number	Diff line number	Diff line change
`@@ -38,40 +38,48 @@ protected T setValue(int i, ByteBuffer value) {`
`38`	`38`	`return (T) this;`
`39`	`39`	`}`
`40`	`40`
	`41`	`+ @Override`
`41`	`42`	`protected ByteBuffer getValue(int i) {`
`42`	`43`	`return values[i];`
`43`	`44`	`}`
`44`	`45`
	`46`	`+ @Override`
`45`	`47`	`public T setBool(int i, boolean v) {`
`46`	`48`	`checkType(i, DataType.Name.BOOLEAN);`
`47`	`49`	`return setValue(i, TypeCodec.booleanCodec.serializeNoBoxing(v));`
`48`	`50`	`}`
`49`	`51`
	`52`	`+ @Override`
`50`	`53`	`public T setInt(int i, int v) {`
`51`	`54`	`checkType(i, DataType.Name.INT);`
`52`	`55`	`return setValue(i, TypeCodec.intCodec.serializeNoBoxing(v));`
`53`	`56`	`}`
`54`	`57`
	`58`	`+ @Override`
`55`	`59`	`public T setLong(int i, long v) {`
`56`	`60`	`checkType(i, DataType.Name.BIGINT, DataType.Name.COUNTER);`
`57`	`61`	`return setValue(i, TypeCodec.longCodec.serializeNoBoxing(v));`
`58`	`62`	`}`
`59`	`63`
	`64`	`+ @Override`
`60`	`65`	`public T setDate(int i, Date v) {`
`61`	`66`	`checkType(i, DataType.Name.TIMESTAMP);`
`62`	`67`	`return setValue(i, v == null ? null : TypeCodec.dateCodec.serialize(v));`
`63`	`68`	`}`
`64`	`69`
	`70`	`+ @Override`
`65`	`71`	`public T setFloat(int i, float v) {`
`66`	`72`	`checkType(i, DataType.Name.FLOAT);`
`67`	`73`	`return setValue(i, TypeCodec.floatCodec.serializeNoBoxing(v));`
`68`	`74`	`}`
`69`	`75`
	`76`	`+ @Override`
`70`	`77`	`public T setDouble(int i, double v) {`
`71`	`78`	`checkType(i, DataType.Name.DOUBLE);`
`72`	`79`	`return setValue(i, TypeCodec.doubleCodec.serializeNoBoxing(v));`
`73`	`80`	`}`
`74`	`81`
	`82`	`+ @Override`
`75`	`83`	`public T setString(int i, String v) {`
`76`	`84`	`DataType.Name type = checkType(i, DataType.Name.VARCHAR, DataType.Name.TEXT, DataType.Name.ASCII);`
`77`	`85`	`switch (type) {`
`@@ -85,25 +93,30 @@ public T setString(int i, String v) {`
`85`	`93`	`}`
`86`	`94`	`}`
`87`	`95`
	`96`	`+ @Override`
`88`	`97`	`public T setBytes(int i, ByteBuffer v) {`
`89`	`98`	`checkType(i, DataType.Name.BLOB);`
`90`	`99`	`return setBytesUnsafe(i, v);`
`91`	`100`	`}`
`92`	`101`
	`102`	`+ @Override`
`93`	`103`	`public T setBytesUnsafe(int i, ByteBuffer v) {`
`94`	`104`	`return setValue(i, v == null ? null : v.duplicate());`
`95`	`105`	`}`
`96`	`106`
	`107`	`+ @Override`
`97`	`108`	`public T setVarint(int i, BigInteger v) {`
`98`	`109`	`checkType(i, DataType.Name.VARINT);`
`99`	`110`	`return setValue(i, v == null ? null : TypeCodec.bigIntegerCodec.serialize(v));`
`100`	`111`	`}`
`101`	`112`
	`113`	`+ @Override`
`102`	`114`	`public T setDecimal(int i, BigDecimal v) {`
`103`	`115`	`checkType(i, DataType.Name.DECIMAL);`
`104`	`116`	`return setValue(i, v == null ? null : TypeCodec.decimalCodec.serialize(v));`
`105`	`117`	`}`
`106`	`118`
	`119`	`+ @Override`
`107`	`120`	`public T setUUID(int i, UUID v) {`
`108`	`121`	`DataType.Name type = checkType(i, DataType.Name.UUID, DataType.Name.TIMEUUID);`
`109`	`122`
`@@ -118,11 +131,13 @@ public T setUUID(int i, UUID v) {`
`118`	`131`	`: setValue(i, TypeCodec.timeUuidCodec.serialize(v));`
`119`	`132`	`}`
`120`	`133`
	`134`	`+ @Override`
`121`	`135`	`public T setInet(int i, InetAddress v) {`
`122`	`136`	`checkType(i, DataType.Name.INET);`
`123`	`137`	`return setValue(i, v == null ? null : TypeCodec.inetCodec.serialize(v));`
`124`	`138`	`}`
`125`	`139`
	`140`	`+ @Override`
`126`	`141`	`public <E> T setList(int i, List<E> v) {`
`127`	`142`	`DataType type = getType(i);`
`128`	`143`	`if (type.getName() != DataType.Name.LIST)`
`@@ -143,6 +158,7 @@ public <E> T setList(int i, List<E> v) {`
`143`	`158`	`return setValue(i, type.codec(protocolVersion).serialize(v));`
`144`	`159`	`}`
`145`	`160`
	`161`	`+ @Override`
`146`	`162`	`public <K, V> T setMap(int i, Map<K, V> v) {`
`147`	`163`	`DataType type = getType(i);`
`148`	`164`	`if (type.getName() != DataType.Name.MAP)`
`@@ -165,6 +181,7 @@ public <K, V> T setMap(int i, Map<K, V> v) {`
`165`	`181`	`return setValue(i, type.codec(protocolVersion).serialize(v));`
`166`	`182`	`}`
`167`	`183`
	`184`	`+ @Override`
`168`	`185`	`public <E> T setSet(int i, Set<E> v) {`
`169`	`186`	`DataType type = getType(i);`
`170`	`187`	`if (type.getName() != DataType.Name.SET)`
`@@ -184,6 +201,7 @@ public <E> T setSet(int i, Set<E> v) {`
`184`	`201`	`return setValue(i, type.codec(protocolVersion).serialize(v));`
`185`	`202`	`}`
`186`	`203`
	`204`	`+ @Override`
`187`	`205`	`public T setUDTValue(int i, UDTValue v) {`
`188`	`206`	`DataType type = getType(i);`
`189`	`207`	`if (type.getName() != DataType.Name.UDT)`
`@@ -196,6 +214,7 @@ public T setUDTValue(int i, UDTValue v) {`
`196`	`214`	`return setValue(i, type.codec(ProtocolVersion.V3).serialize(v));`
`197`	`215`	`}`
`198`	`216`
	`217`	`+ @Override`
`199`	`218`	`public T setTupleValue(int i, TupleValue v) {`
`200`	`219`	`DataType type = getType(i);`
`201`	`220`	`if (type.getName() != DataType.Name.TUPLE)`
`@@ -208,6 +227,7 @@ public T setTupleValue(int i, TupleValue v) {`
`208`	`227`	`return setValue(i, type.codec(ProtocolVersion.V3).serialize(v));`
`209`	`228`	`}`
`210`	`229`
	`230`	`+ @Override`
`211`	`231`	`public T setToNull(int i) {`
`212`	`232`	`return setValue(i, null);`
`213`	`233`	`}`