public <K, V> Map<K, V> getFrozenMap(String column, AbstractType<K> keyType, AbstractType<V> valueType) { ByteBuffer raw = data.get(column); return raw == null ? null : MapType.getInstance(keyType, valueType, false).compose(raw); }
private int compareMapType(MapType<?, ?> type, MapType<?, ?> otherType) { int test = compare(type.getKeysType(), otherType.getKeysType()); return test != 0 ? test : compare(type.getValuesType(), otherType.getValuesType()); }
MapSerializer mapSerializer = mapType.getSerializer(); Map outputCollection = new HashMap(); if (useNativeProtocol2) UserType usertype = (UserType) mapType.getValuesType();
Object valueClassInstance = valueClass.getDeclaredField("instance").get(null); MapType mapType = MapType.getInstance((AbstractType) keyClassInstance, (AbstractType) valueClassInstance, false); return mapType.decompose((Map) value).array();
Object valueClassInstance = valueClass.getDeclaredField("instance").get(null); valueType = MapType.getInstance((AbstractType) keyClassInstance, (AbstractType) valueClassInstance, true) .toString();
public static Value fromSerialized(ByteBuffer value, MapType type, ProtocolVersion version) throws InvalidRequestException { try { // Collections have this small hack that validate cannot be called on a serialized object, // but compose does the validation (so we're fine). Map<?, ?> m = type.getSerializer().deserializeForNativeProtocol(value, version); Map<ByteBuffer, ByteBuffer> map = new LinkedHashMap<>(m.size()); for (Map.Entry<?, ?> entry : m.entrySet()) map.put(type.getKeysType().decompose(entry.getKey()), type.getValuesType().decompose(entry.getValue())); return new Value(map); } catch (MarshalException e) { throw new InvalidRequestException(e.getMessage()); } }
private static AbstractType<?> expandUserTypes(AbstractType<?> original) { if (original instanceof UserType) return new TupleType(expandUserTypes(((UserType) original).fieldTypes())); if (original instanceof TupleType) return new TupleType(expandUserTypes(((TupleType) original).allTypes())); if (original instanceof ListType<?>) return ListType.getInstance(expandUserTypes(((ListType<?>) original).getElementsType()), original.isMultiCell()); if (original instanceof MapType<?,?>) { MapType<?, ?> mt = (MapType<?, ?>) original; return MapType.getInstance(expandUserTypes(mt.getKeysType()), expandUserTypes(mt.getValuesType()), mt.isMultiCell()); } if (original instanceof SetType<?>) return SetType.getInstance(expandUserTypes(((SetType<?>) original).getElementsType()), original.isMultiCell()); // this is very unlikely to ever happen, but it's better to be safe than sorry if (original instanceof ReversedType<?>) return ReversedType.getInstance(expandUserTypes(((ReversedType) original).baseType)); if (original instanceof CompositeType) return CompositeType.getInstance(expandUserTypes(original.getComponents())); return original; }
case MAP: MapType<?,?> mapType = (MapType<?, ?>)type; return mapType.compose(foundValue).containsValue(mapType.getValuesType().compose(value)); return foundValue != null && mapType.getSerializer().getSerializedValue(foundValue, value, mapType.getKeysType()) != null;
public boolean isSatisfiedBy(CFMetaData metadata, DecoratedKey partitionKey, Row row) { assert key != null; // We support null conditions for LWT (in ColumnCondition) but not for RowFilter. // TODO: we should try to merge both code someday. assert value != null; if (row.isStatic() != column.isStatic()) return true; MapType<?, ?> mt = (MapType<?, ?>)column.type; if (column.isComplex()) { Cell cell = row.getCell(column, CellPath.create(key)); return cell != null && mt.valueComparator().compare(cell.value(), value) == 0; } else { ByteBuffer serializedMap = getValue(metadata, partitionKey, row); if (serializedMap == null) return false; ByteBuffer foundValue = mt.getSerializer().getSerializedValue(serializedMap, key, mt.getKeysType()); return foundValue != null && mt.valueComparator().compare(foundValue, value) == 0; } }
@Override public AbstractType<?> freezeNestedMulticellTypes() { if (!isMultiCell()) return this; AbstractType<?> keyType = (keys.isFreezable() && keys.isMultiCell()) ? keys.freeze() : keys.freezeNestedMulticellTypes(); AbstractType<?> valueType = (values.isFreezable() && values.isMultiCell()) ? values.freeze() : values.freezeNestedMulticellTypes(); return getInstance(keyType, valueType, isMultiCell); }
try mapType = MapType.getInstance(new TypeParser(cqlColumnMetadata.substring( cqlColumnMetadata.indexOf("("), cqlColumnMetadata.length())));
if (((MapType) type).getValuesType().getClass().getSimpleName().equals("UserType"))
public static ColumnSpecification keySpecOf(ColumnSpecification column) { return new ColumnSpecification(column.ksName, column.cfName, new ColumnIdentifier("key(" + column.name + ")", true), ((MapType)column.type).getKeysType()); }
@Override public String toString() { MapType<?, ?> mt = (MapType<?, ?>)column.type; return String.format("%s[%s] = %s", column.name, mt.nameComparator().getString(key), mt.valueComparator().getString(value)); }
public AbstractType<?> thriftColumnNameType() { if (isSuper()) { ColumnDefinition def = compactValueColumn(); assert def != null && def.type instanceof MapType; return ((MapType)def.type).nameComparator(); } assert isStaticCompactTable(); return clusteringColumns.get(0).type; }
@Override public int compareCustom(ByteBuffer o1, ByteBuffer o2) { return compareMaps(keys, values, o1, o2); }
public static synchronized <K, V> MapType<K, V> getInstance(AbstractType<K> keys, AbstractType<V> values, boolean isMultiCell) { Map<Pair<AbstractType<?>, AbstractType<?>>, MapType> internMap = isMultiCell ? instances : frozenInstances; Pair<AbstractType<?>, AbstractType<?>> p = Pair.<AbstractType<?>, AbstractType<?>>create(keys, values); MapType<K, V> t = internMap.get(p); if (t == null) { t = new MapType<>(keys, values, isMultiCell); internMap.put(p, t); } return t; }
public String toString(boolean ignoreFreezing) { boolean includeFrozenType = !ignoreFreezing && !isMultiCell(); StringBuilder sb = new StringBuilder(); if (includeFrozenType) sb.append(FrozenType.class.getName()).append("("); sb.append(getClass().getName()).append(TypeParser.stringifyTypeParameters(Arrays.asList(keys, values), ignoreFreezing || !isMultiCell)); if (includeFrozenType) sb.append(")"); return sb.toString(); }
protected ResultMessage formatResults(List<RoleResource> sortedRoles) { ResultSet result = new ResultSet(metadata); IRoleManager roleManager = DatabaseDescriptor.getRoleManager(); for (RoleResource role : sortedRoles) { result.addColumnValue(UTF8Type.instance.decompose(role.getRoleName())); result.addColumnValue(BooleanType.instance.decompose(roleManager.isSuper(role))); result.addColumnValue(BooleanType.instance.decompose(roleManager.canLogin(role))); result.addColumnValue(optionsType.decompose(roleManager.getCustomOptions(role))); } return new ResultMessage.Rows(result); } }
public static Value fromSerialized(ByteBuffer value, MapType type, ProtocolVersion version) throws InvalidRequestException { try { // Collections have this small hack that validate cannot be called on a serialized object, // but compose does the validation (so we're fine). Map<?, ?> m = type.getSerializer().deserializeForNativeProtocol(value, version); Map<ByteBuffer, ByteBuffer> map = new LinkedHashMap<>(m.size()); for (Map.Entry<?, ?> entry : m.entrySet()) map.put(type.getKeysType().decompose(entry.getKey()), type.getValuesType().decompose(entry.getValue())); return new Value(map); } catch (MarshalException e) { throw new InvalidRequestException(e.getMessage()); } }