public <T> Deserializer<T> getDeserializer(Class<T> c) { Serialization<T> serializer = getSerialization(c); if (serializer != null) { return serializer.getDeserializer(c); } return null; }
public <T> Serializer<T> getSerializer(Class<T> c) { Serialization<T> serializer = getSerialization(c); if (serializer != null) { return serializer.getSerializer(c); } return null; }
protected DeserializerComparator(Deserializer<T> deserializer) throws IOException { this.deserializer = deserializer; this.deserializer.open(buffer); }
public DefaultStringifier(Configuration conf, Class<T> c) { SerializationFactory factory = new SerializationFactory(conf); this.serializer = factory.getSerializer(c); this.deserializer = factory.getDeserializer(c); this.inBuf = new DataInputBuffer(); this.outBuf = new DataOutputBuffer(); try { serializer.open(outBuf); deserializer.open(inBuf); } catch (IOException ex) { throw new RuntimeException(ex); } }
/** * @param serialization External serializer to wrap. * @param cls The class to serialize. */ public HadoopSerializationWrapper(Serialization<T> serialization, Class<T> cls) throws IgniteCheckedException { assert cls != null; serializer = serialization.getSerializer(cls); deserializer = serialization.getDeserializer(cls); try { serializer.open(outStream); deserializer.open(inStream); } catch (IOException e) { throw new IgniteCheckedException(e); } }
BlockCompressWriter(Configuration conf, Option... options) throws IOException { super(conf, options); compressionBlockSize = conf.getInt(IO_SEQFILE_COMPRESS_BLOCKSIZE_KEY, IO_SEQFILE_COMPRESS_BLOCKSIZE_DEFAULT ); keySerializer.close(); keySerializer.open(keyBuffer); uncompressedValSerializer.close(); uncompressedValSerializer.open(valBuffer); }
@SuppressWarnings("unchecked") private Object deserializeValue(Object val) throws IOException { return valDeserializer.deserialize(val); }
@Override public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) { try { buffer.reset(b1, s1, l1); key1 = deserializer.deserialize(key1); buffer.reset(b2, s2, l2); key2 = deserializer.deserialize(key2); } catch (IOException e) { throw new RuntimeException(e); } return compare(key1, key2); }
private static SerializationFactory getFactory(Configuration conf) { if (serialFactory == null) { serialFactory = new SerializationFactory(conf); } return serialFactory; }
/** {@inheritDoc} */ @Override public void write(DataOutput out, Object obj) throws IgniteCheckedException { assert out != null; assert obj != null; try { currOut = (OutputStream)out; serializer.serialize((T)obj); currOut = null; } catch (IOException e) { throw new IgniteCheckedException(e); } }
@SuppressWarnings("unchecked") private Deserializer getDeserializer(SerializationFactory sf, Class c) { return sf.getDeserializer(c); }
@InterfaceAudience.Private @Override public Deserializer<Writable> getDeserializer(Class<Writable> c) { return new WritableDeserializer(getConf(), c); }
@SuppressWarnings("unchecked") public <T> Serialization<T> getSerialization(Class<T> c) { for (Serialization serialization : serializations) { if (serialization.accept(c)) { return (Serialization<T>) serialization; } } return null; }
public WritableDeserializer(Configuration conf, Class<?> c) { setConf(conf); this.writableClass = c; }
@Override @InterfaceAudience.Private public Deserializer<Serializable> getDeserializer(Class<Serializable> c) { return new JavaSerializationDeserializer<Serializable>(); }
@Override @InterfaceAudience.Private public Serializer<Serializable> getSerializer(Class<Serializable> c) { return new JavaSerializationSerializer(); }
@Override public void setConf(Configuration conf) { super.setConf(conf); flags.put("serializationWasConfigured", true); } }
@SuppressWarnings("unchecked") private Object deserializeKey(Object key) throws IOException { return keyDeserializer.deserialize(key); }