public void udtSerDeserTest(int version) throws Exception {
ListType<?> lt = ListType.getInstance(Int32Type.instance, true);
SetType<?> st = SetType.getInstance(UTF8Type.instance, true);
MapType<?, ?> mt = MapType.getInstance(UTF8Type.instance, LongType.instance, true);
UserType udt =
new UserType(
"ks",
bb("myType"),
Arrays.asList(bb("f1"), bb("f2"), bb("f3"), bb("f4")),
Arrays.asList(LongType.instance, lt, st, mt));
Map<ColumnIdentifier, Term.Raw> value = new HashMap<>();
value.put(ci("f1"), lit(42));
value.put(ci("f2"), new Lists.Literal(Arrays.<Term.Raw>asList(lit(3), lit(1))));
value.put(ci("f3"), new Sets.Literal(Arrays.<Term.Raw>asList(lit("foo"), lit("bar"))));
value.put(
ci("f4"),
new Maps.Literal(
Arrays.<Pair<Term.Raw, Term.Raw>>asList(
Pair.<Term.Raw, Term.Raw>create(lit("foo"), lit(24)),
Pair.<Term.Raw, Term.Raw>create(lit("bar"), lit(12)))));
UserTypes.Literal u = new UserTypes.Literal(value);
Term t = u.prepare("ks", columnSpec("myValue", udt));
QueryOptions options = QueryOptions.DEFAULT;
if (version == 2)
options =
QueryOptions.fromProtocolV2(ConsistencyLevel.ONE, Collections.<ByteBuffer>emptyList());
else if (version != 3) throw new AssertionError("Invalid protocol version for test");
ByteBuffer serialized = t.bindAndGet(options);
ByteBuffer[] fields = udt.split(serialized);
assertEquals(4, fields.length);
assertEquals(bytes(42L), fields[0]);
// Note that no matter what the protocol version has been used in bindAndGet above, the
// collections inside
// a UDT should alway be serialized with version 3 of the protocol. Which is why we don't use
// 'version'
// on purpose below.
assertEquals(
Arrays.asList(3, 1), lt.getSerializer().deserializeForNativeProtocol(fields[1], 3));
LinkedHashSet<String> s = new LinkedHashSet<>();
s.addAll(Arrays.asList("bar", "foo"));
assertEquals(s, st.getSerializer().deserializeForNativeProtocol(fields[2], 3));
LinkedHashMap<String, Long> m = new LinkedHashMap<>();
m.put("bar", 12L);
m.put("foo", 24L);
assertEquals(m, mt.getSerializer().deserializeForNativeProtocol(fields[3], 3));
}
@Override
public MapType marshal(Map<K, V> v) throws Exception {
MapType<K, V> mapType = new MapType<K, V>();
for (Map.Entry<K, V> entry : v.entrySet()) {
MapEntryType<K, V> mapEntryType = new MapEntryType<K, V>();
mapEntryType.setKey(entry.getKey());
mapEntryType.setValue(entry.getValue());
mapType.getEntry().add(mapEntryType);
}
return mapType;
}
private JavaType _mapType(Class<?> rawClass) {
JavaType[] typeParams = findParameterTypes(rawClass, Map.class);
// ok to have no types ("raw")
if (typeParams == null) {
return MapType.construct(rawClass, _unknownType(), _unknownType());
}
// but exactly 2 types if any found
if (typeParams.length != 2) {
throw new IllegalArgumentException(
"Strange Map type " + rawClass.getName() + ": can not determine type parameters");
}
return MapType.construct(rawClass, typeParams[0], typeParams[1]);
}
/** Method used by {@link TypeParser} when generics-aware version is constructed. */
protected JavaType _fromParameterizedClass(Class<?> clz, List<JavaType> paramTypes) {
if (clz.isArray()) { // ignore generics (should never have any)
return ArrayType.construct(_fromType(clz.getComponentType(), null));
}
if (clz.isEnum()) { // ditto for enums
return new SimpleType(clz);
}
if (Map.class.isAssignableFrom(clz)) {
// First: if we do have param types, use them
JavaType keyType, contentType;
if (paramTypes.size() > 0) {
keyType = paramTypes.get(0);
contentType = (paramTypes.size() >= 2) ? paramTypes.get(1) : _unknownType();
return MapType.construct(clz, keyType, contentType);
}
return _mapType(clz);
}
if (Collection.class.isAssignableFrom(clz)) {
if (paramTypes.size() >= 1) {
return CollectionType.construct(clz, paramTypes.get(0));
}
return _collectionType(clz);
}
if (paramTypes.size() == 0) {
return new SimpleType(clz);
}
JavaType[] pt = paramTypes.toArray(new JavaType[paramTypes.size()]);
return _constructSimple(clz, pt);
}
/**
* Factory method for constructing {@link JavaType} that represents a parameterized type. For
* example, to represent type <code>List<Set<Integer>></code>, you could call
*
* <pre>
* JavaType inner = TypeFactory.parametricType(Set.class, Integer.class);
* TypeFactory.parametricType(List.class, inner);
* </pre>
*
* @since 1.5
*/
public static JavaType parametricType(Class<?> parametrized, JavaType... parameterTypes) {
// Need to check kind of class we are dealing with...
if (parametrized.isArray()) {
// 19-Jan-2010, tatus: should we support multi-dimensional arrays directly?
if (parameterTypes.length != 1) {
throw new IllegalArgumentException(
"Need exactly 1 parameter type for arrays (" + parametrized.getName() + ")");
}
return ArrayType.construct(parameterTypes[0]);
}
if (Map.class.isAssignableFrom(parametrized)) {
if (parameterTypes.length != 2) {
throw new IllegalArgumentException(
"Need exactly 2 parameter types for Map types (" + parametrized.getName() + ")");
}
return MapType.construct(parametrized, parameterTypes[0], parameterTypes[1]);
}
if (Collection.class.isAssignableFrom(parametrized)) {
if (parameterTypes.length != 1) {
throw new IllegalArgumentException(
"Need exactly 1 parameter type for Collection types (" + parametrized.getName() + ")");
}
return CollectionType.construct(parametrized, parameterTypes[0]);
}
return _constructSimple(parametrized, parameterTypes);
}
/**
* Set the type of the Google map.
*
* @param type the map type
* @since 1.9.0
*/
@Api
public void setMapType(MapType type) {
this.type = type;
if (googleMap != null) {
setMapType(googleMap, type.toString());
}
}
public void collectionSerDeserTest(int version) throws Exception {
// Lists
ListType<?> lt = ListType.getInstance(Int32Type.instance, true);
List<Integer> l = Arrays.asList(2, 6, 1, 9);
List<ByteBuffer> lb = new ArrayList<>(l.size());
for (Integer i : l) lb.add(Int32Type.instance.decompose(i));
assertEquals(
l,
lt.getSerializer()
.deserializeForNativeProtocol(
CollectionSerializer.pack(lb, lb.size(), version), version));
// Sets
SetType<?> st = SetType.getInstance(UTF8Type.instance, true);
Set<String> s = new LinkedHashSet<>();
s.addAll(Arrays.asList("bar", "foo", "zee"));
List<ByteBuffer> sb = new ArrayList<>(s.size());
for (String t : s) sb.add(UTF8Type.instance.decompose(t));
assertEquals(
s,
st.getSerializer()
.deserializeForNativeProtocol(
CollectionSerializer.pack(sb, sb.size(), version), version));
// Maps
MapType<?, ?> mt = MapType.getInstance(UTF8Type.instance, LongType.instance, true);
Map<String, Long> m = new LinkedHashMap<>();
m.put("bar", 12L);
m.put("foo", 42L);
m.put("zee", 14L);
List<ByteBuffer> mb = new ArrayList<>(m.size() * 2);
for (Map.Entry<String, Long> entry : m.entrySet()) {
mb.add(UTF8Type.instance.decompose(entry.getKey()));
mb.add(LongType.instance.decompose(entry.getValue()));
}
assertEquals(
m,
mt.getSerializer()
.deserializeForNativeProtocol(
CollectionSerializer.pack(mb, m.size(), version), version));
}
@Override
public Map<K, V> unmarshal(MapType<K, V> v) throws Exception {
HashMap<K, V> map = new HashMap<K, V>();
for (MapEntryType<K, V> mapEntryType : v.getEntry()) {
map.put(mapEntryType.getKey(), mapEntryType.getValue());
}
return map;
}
public void save(long locationId, String shapeFile, Map<String, Double> parameterMap) {
if (!isValidInput(locationId, shapeFile, parameterMap)) return;
File file = getParameterFile(locationId, shapeFile);
if (!file.exists()) if (!create(file)) return;
try (FileWriter writer = new FileWriter(file)) {
gson.toJson(parameterMap, MapType.get(), writer);
} catch (IOException e) {
log.warn("Error saving file to parameter repository", e);
}
}
public Map<String, Double> load(long locationId, String shapeFile) {
if (!contains(locationId, shapeFile)) // also checks that input
// is valid
return null;
File file = getParameterFile(locationId, shapeFile);
try (FileReader reader = new FileReader(file)) {
return gson.fromJson(reader, MapType.get());
} catch (IOException e) {
log.warn("Error loading file from parameter repository", e);
return null;
}
}
/**
* This method deals with parameterized types, that is, first class generic classes.
*
* <p>Since version 1.2, this resolves all parameterized types, not just Maps or Collections.
*/
protected JavaType _fromParamType(ParameterizedType type, TypeBindings context) {
/* First: what is the actual base type? One odd thing
* is that 'getRawType' returns Type, not Class<?> as
* one might expect. But let's assume it is always of
* type Class: if not, need to add more code to resolve
* it to Class.
*/
Class<?> rawType = (Class<?>) type.getRawType();
Type[] args = type.getActualTypeArguments();
// Ok: Map or Collection?
if (Map.class.isAssignableFrom(rawType)) {
if (args.length != 2) {
throw new IllegalArgumentException(
"Could not find 2 type parameters for class "
+ rawType.getName()
+ " (found "
+ args.length
+ ")");
}
JavaType keyType = _fromType(args[0], context);
JavaType valueType = _fromType(args[1], context);
return MapType.construct(rawType, keyType, valueType);
}
if (Collection.class.isAssignableFrom(rawType)) {
JavaType valueType = _fromType(args[0], context);
return CollectionType.construct(rawType, valueType);
}
int len = (args == null) ? 0 : args.length;
if (len == 0) { // no generics
return new SimpleType(rawType);
}
JavaType[] pt = new JavaType[len];
for (int i = 0; i < len; ++i) {
pt[i] = _fromType(args[i], context);
}
return _constructSimple(rawType, pt);
}
@Override
public void onDraw() {
if (googleMap == null) {
// create as first child of raster group
map.getRasterContext().drawGroup(null, this);
String id = map.getRasterContext().getId(this);
// move to first position
Element mapDiv = DOM.getElementById(id);
Element rasterGroup =
DOM.getElementById(map.getRasterContext().getId(map.getGroup(RenderGroup.RASTER)));
DOM.insertBefore(DOM.getParent(rasterGroup), mapDiv, rasterGroup);
String graphicsId = map.getVectorContext().getId();
googleMap =
createGoogleMap(
id,
graphicsId,
type.name(),
showMap,
getVerticalMargin(),
getHorizontalMargin(),
getVerticalAlignmentString());
}
}
/**
* Convenience factory method for constructing {@link JavaType} that represent Map of specified
* type and contains elements of specified type
*
* @since 1.3
*/
@SuppressWarnings("unchecked")
public static JavaType mapType(
Class<? extends Map> mapType, JavaType keyType, JavaType valueType) {
return MapType.construct(mapType, keyType, valueType);
}
@Override
Optional<TypeSpec.Builder> write(ClassName generatedTypeName, ProvisionBinding binding) {
// We don't want to write out resolved bindings -- we want to write out the generic version.
checkState(!binding.unresolved().isPresent());
TypeMirror keyType =
binding.contributionType().equals(ContributionType.MAP)
? MapType.from(binding.key().type()).unwrappedValueType(Provider.class)
: binding.key().type();
TypeName providedTypeName = TypeName.get(keyType);
ParameterizedTypeName parameterizedFactoryName = factoryOf(providedTypeName);
Optional<ParameterizedTypeName> factoryOfRawTypeName = Optional.absent();
TypeSpec.Builder factoryBuilder;
Optional<MethodSpec.Builder> constructorBuilder = Optional.absent();
ImmutableList<TypeVariableName> typeParameters = bindingTypeElementTypeVariableNames(binding);
ImmutableMap<BindingKey, FrameworkField> fields =
generateBindingFieldsForDependencies(dependencyRequestMapper, binding);
switch (binding.factoryCreationStrategy()) {
case ENUM_INSTANCE:
factoryBuilder = enumBuilder(generatedTypeName.simpleName()).addEnumConstant("INSTANCE");
// If we have type parameters, then remove the parameters from our providedTypeName,
// since we'll be implementing an erased version of it.
if (!typeParameters.isEmpty()) {
factoryBuilder.addAnnotation(SUPPRESS_WARNINGS_RAWTYPES);
// TODO(ronshapiro): instead of reassigning, introduce an optional/second parameter
providedTypeName = ((ParameterizedTypeName) providedTypeName).rawType;
factoryOfRawTypeName = Optional.of(factoryOf(providedTypeName));
}
break;
case CLASS_CONSTRUCTOR:
factoryBuilder =
classBuilder(generatedTypeName.simpleName())
.addTypeVariables(typeParameters)
.addModifiers(FINAL);
constructorBuilder = Optional.of(constructorBuilder().addModifiers(PUBLIC));
if (binding.bindingKind().equals(PROVISION)
&& !binding.bindingElement().getModifiers().contains(STATIC)) {
addConstructorParameterAndTypeField(
TypeName.get(binding.bindingTypeElement().asType()),
"module",
factoryBuilder,
constructorBuilder.get());
}
for (FrameworkField bindingField : fields.values()) {
addConstructorParameterAndTypeField(
bindingField.javapoetFrameworkType(),
bindingField.name(),
factoryBuilder,
constructorBuilder.get());
}
break;
default:
throw new AssertionError();
}
factoryBuilder
.addModifiers(PUBLIC)
.addSuperinterface(factoryOfRawTypeName.or(parameterizedFactoryName));
// If constructing a factory for @Inject or @Provides bindings, we use a static create method
// so that generated components can avoid having to refer to the generic types
// of the factory. (Otherwise they may have visibility problems referring to the types.)
Optional<MethodSpec> createMethod;
switch (binding.bindingKind()) {
case INJECTION:
case PROVISION:
// The return type is usually the same as the implementing type, except in the case
// of enums with type variables (where we cast).
MethodSpec.Builder createMethodBuilder =
methodBuilder("create")
.addModifiers(PUBLIC, STATIC)
.addTypeVariables(typeParameters)
.returns(parameterizedFactoryName);
List<ParameterSpec> params =
constructorBuilder.isPresent()
? constructorBuilder.get().build().parameters
: ImmutableList.<ParameterSpec>of();
createMethodBuilder.addParameters(params);
switch (binding.factoryCreationStrategy()) {
case ENUM_INSTANCE:
if (typeParameters.isEmpty()) {
createMethodBuilder.addStatement("return INSTANCE");
} else {
// We use an unsafe cast here because the types are different.
// It's safe because the type is never referenced anywhere.
createMethodBuilder.addStatement("return ($T) INSTANCE", TypeNames.FACTORY);
createMethodBuilder.addAnnotation(SUPPRESS_WARNINGS_UNCHECKED);
}
break;
case CLASS_CONSTRUCTOR:
createMethodBuilder.addStatement(
"return new $T($L)",
javapoetParameterizedGeneratedTypeNameForBinding(binding),
makeParametersCodeBlock(Lists.transform(params, CodeBlocks.PARAMETER_NAME)));
break;
default:
throw new AssertionError();
}
createMethod = Optional.of(createMethodBuilder.build());
break;
default:
createMethod = Optional.absent();
}
if (constructorBuilder.isPresent()) {
factoryBuilder.addMethod(constructorBuilder.get().build());
}
List<CodeBlock> parameters = Lists.newArrayList();
for (DependencyRequest dependency : binding.dependencies()) {
parameters.add(
frameworkTypeUsageStatement(
CodeBlocks.format("$L", fields.get(dependency.bindingKey()).name()),
dependency.kind()));
}
CodeBlock parametersCodeBlock = makeParametersCodeBlock(parameters);
MethodSpec.Builder getMethodBuilder =
methodBuilder("get")
.returns(providedTypeName)
.addAnnotation(Override.class)
.addModifiers(PUBLIC);
if (binding.bindingKind().equals(PROVISION)) {
CodeBlock.Builder providesMethodInvocationBuilder = CodeBlock.builder();
if (binding.bindingElement().getModifiers().contains(STATIC)) {
providesMethodInvocationBuilder.add("$T", ClassName.get(binding.bindingTypeElement()));
} else {
providesMethodInvocationBuilder.add("module");
}
providesMethodInvocationBuilder.add(
".$L($L)", binding.bindingElement().getSimpleName(), parametersCodeBlock);
CodeBlock providesMethodInvocation = providesMethodInvocationBuilder.build();
if (binding.provisionType().equals(SET)) {
TypeName paramTypeName =
TypeName.get(MoreTypes.asDeclared(keyType).getTypeArguments().get(0));
// TODO(cgruber): only be explicit with the parameter if paramType contains wildcards.
getMethodBuilder.addStatement(
"return $T.<$T>singleton($L)",
Collections.class,
paramTypeName,
providesMethodInvocation);
} else if (binding.nullableType().isPresent()
|| nullableValidationType.equals(Diagnostic.Kind.WARNING)) {
if (binding.nullableType().isPresent()) {
getMethodBuilder.addAnnotation((ClassName) TypeName.get(binding.nullableType().get()));
}
getMethodBuilder.addStatement("return $L", providesMethodInvocation);
} else {
String failMsg = CANNOT_RETURN_NULL_FROM_NON_NULLABLE_PROVIDES_METHOD;
getMethodBuilder
.addStatement(
"$T provided = $L", getMethodBuilder.build().returnType, providesMethodInvocation)
.addCode("if (provided == null) { ")
.addStatement("throw new $T($S)", NullPointerException.class, failMsg)
.addCode("}")
.addStatement("return provided");
}
} else if (binding.membersInjectionRequest().isPresent()) {
getMethodBuilder.addStatement(
"$1T instance = new $1T($2L)", providedTypeName, parametersCodeBlock);
getMethodBuilder.addStatement(
"$L.injectMembers(instance)",
fields.get(binding.membersInjectionRequest().get().bindingKey()).name());
getMethodBuilder.addStatement("return instance");
} else {
getMethodBuilder.addStatement("return new $T($L)", providedTypeName, parametersCodeBlock);
}
factoryBuilder.addMethod(getMethodBuilder.build());
if (createMethod.isPresent()) {
factoryBuilder.addMethod(createMethod.get());
}
// TODO(gak): write a sensible toString
return Optional.of(factoryBuilder);
}
