Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.datastax.driver.mapping;
  
  import java.util.*;
  
  
An object handling the mapping of a particular class to a UDT.

A UDTMapper object is obtained from a MappingManager using the MappingManager.udtMapper(java.lang.Class) method.

 
 public class UDTMapper<T> {
     // UDTs are always serialized with the v3 protocol
     private static final int UDT_PROTOCOL_VERSION = Math.max(., 3);
 
     private final EntityMapper<T> entityMapper;
     private final UserType userType;
 
     UDTMapper(EntityMapper<T> entityMapperSession session) {
         this. = entityMapper;
 
         String keyspace = entityMapper.getKeyspace();
         String udt = entityMapper.getTable();
          = session.getCluster().getMetadata().getKeyspace(keyspace).getUserType(udt);
         if ( == null) {
             throw new IllegalArgumentException(String.format("Type \"%s\" does not exist in keyspace \"%s\""udtkeyspace));
         }
     }

    
Converts a com.datastax.driver.core.UDTValue (returned by the core API) to the mapped class.

Parameters:
v the UDTValue.
Returns:
an instance of the mapped class.
Throws:
java.lang.IllegalArgumentException if the UDTValue is not of the type indicated in the mapped class's @UDT annotation.
 
     public T map(UDTValue v) {
         if (!v.getType().equals()) {
             String message = String.format("UDT conversion mismatch: expected type %s, got %s",
                                            v.getType());
             throw new IllegalArgumentException(message);
         }
         return toEntity(v);
     }
 
     UserType getUserType() {
         return ;
     }
 
     UDTValue toUDTValue(T entity) {
         UDTValue udtValue = .newValue();
         for (ColumnMapper<T> cm : .allColumns()) {
             Object value = cm.getValue(entity);
             udtValue.setBytesUnsafe(cm.getColumnName(), value == null ? null : cm.getDataType().serialize(value));
         }
         return udtValue;
     }
 
     List<UDTValuetoUDTValues(List<T> entities) {
         List<UDTValueudtValues = new ArrayList<UDTValue>(entities.size());
         for (T entity : entities) {
             UDTValue udtValue = toUDTValue(entity);
             udtValues.add(udtValue);
         }
         return udtValues;
     }
 
     Set<UDTValuetoUDTValues(Set<T> entities) {
         Set<UDTValueudtValues = Sets.newHashSetWithExpectedSize(entities.size());
         for (T entity : entities) {
             UDTValue udtValue = toUDTValue(entity);
             udtValues.add(udtValue);
         }
         return udtValues;
     }
 
     /*
      * Map conversion methods are static because they use two mappers, either of
      * which (but not both) may be null.
      *
      * This reflects the fact that the map datatype can use UDTs as keys, or
      * values, or both.
      */
     static <K, V> Map<ObjectObjecttoUDTValues(Map<K, V> entitiesUDTMapper<K> keyMapperUDTMapper<V> valueMapper) {
         assert keyMapper != null || valueMapper != null;
         Map<ObjectObjectudtValues = Maps.newHashMapWithExpectedSize(entities.size());
         for (Entry<K, V> entry : entities.entrySet()) {
             Object key = (keyMapper == null) ? entry.getKey() : keyMapper.toUDTValue(entry.getKey());
             Object value = (valueMapper == null) ? entry.getValue() : valueMapper.toUDTValue(entry.getValue());
            udtValues.put(keyvalue);
        }
        return udtValues;
    }
    T toEntity(UDTValue udtValue) {
        T entity = .newEntity();
        for (ColumnMapper<T> cm : .allColumns()) {
            ByteBuffer bytes = udtValue.getBytesUnsafe(cm.getColumnName());
            if (bytes != null)
                cm.setValue(entitycm.getDataType().deserialize(bytes));
        }
        return entity;
    }
    List<T> toEntities(List<UDTValueudtValues) {
        List<T> entities = new ArrayList<T>(udtValues.size());
        for (UDTValue udtValue : udtValues) {
            entities.add(toEntity(udtValue));
        }
        return entities;
    }
    Set<T> toEntities(Set<UDTValueudtValues) {
        Set<T> entities = Sets.newHashSetWithExpectedSize(udtValues.size());
        for (UDTValue udtValue : udtValues) {
            entities.add(toEntity(udtValue));
        }
        return entities;
    }
    @SuppressWarnings("unchecked")
    static <K, V> Map<K, V> toEntities(Map<ObjectObjectudtValuesUDTMapper<K> keyMapperUDTMapper<V> valueMapper) {
        Map<K, V> entities = Maps.newHashMapWithExpectedSize(udtValues.size());
        for (Entry<ObjectObjectentry : udtValues.entrySet()) {
            K key = (keyMapper == null) ? (K) entry.getKey() : keyMapper.toEntity((UDTValueentry.getKey());
            V value = (valueMapper == null) ? (V) entry.getValue() : valueMapper.toEntity((UDTValue)entry.getValue());
            entities.put(keyvalue);
        }
        return entities;
    }
New to GrepCode? Check out our FAQ X